input stringlengths 1 785 | output dict | schema listlengths 0 0 |
|---|---|---|
At the most basic level, we say that two intrusion events are attributed to the same group when we have collected enough indicators to show beyond a reasonable doubt that the same actor or group of actors were involved. | {
"entities": {}
} | [] |
We track all of the indicators and significant linkages associated with identified threat groups in a proprietary database that comprises millions of nodes and linkages between them. | {
"entities": {}
} | [] |
In this way, we can always go back and answer'' why'' we associated cyber threat activity with a particular group. | {
"entities": {}
} | [] |
SOURFACE is a downloader that obtains a second stage backdoor from a C2 server. | {
"entities": {
"entity": [
{
"text": "SOURFACE",
"start": 0,
"end": 8
},
{
"text": "a downloader",
"start": 12,
"end": 24
},
{
"text": "a second stage backdoor",
"start": 38,
"end": 61
},
{
"... | [] |
Over time the downloader has evolved and the newer versions, usually compiled with the DLL name'coreshell.dll', are distinct enough from the older versions that we refer to it as SOURFACE/CORESHELL or simply CORESHELL. | {
"entities": {}
} | [] |
This appendix focuses on these newer versions. | {
"entities": {}
} | [] |
CORESHELL uses two threads to communicate with its C2 server. | {
"entities": {
"entity": [
{
"text": "CORESHELL",
"start": 0,
"end": 9
},
{
"text": "two threads",
"start": 15,
"end": 26
},
{
"text": "communicate with its C2 server",
"start": 30,
"end": 60
}
],
... | [] |
The first thread sends beacons that contain the process listing of the compromised host. | {
"entities": {
"entity": [
{
"text": "The first thread",
"start": 0,
"end": 16
},
{
"text": "beacons that contain the process listing of the compromised host",
"start": 23,
"end": 87
}
],
"action": [
{
"text": "sends",
... | [] |
The second thread is responsible for downloading and executing stage two payloads. | {
"entities": {
"entity": [
{
"text": "The second thread",
"start": 0,
"end": 17
},
{
"text": "stage two payloads",
"start": 63,
"end": 81
}
],
"action": [
{
"text": "downloading",
"start": 37,
"end": 48
... | [] |
Messages are sent using HTTP POST requests whose bodies contain encrypted and Base64 encoded data. | {
"entities": {
"entity": [
{
"text": "Messages",
"start": 0,
"end": 8
},
{
"text": "HTTP POST requests",
"start": 24,
"end": 42
},
{
"text": "encrypted and Base64 encoded data",
"start": 64,
"end": 97
}
... | [] |
The encryption algorithm is a custom stream cipher using a six-byte key. | {
"entities": {}
} | [] |
Commands from the controller to the CORESHELL implant are encrypted using another stream cipher but this time using an eight-byte key. | {
"entities": {
"entity": [
{
"text": "Commands from the controller to the CORESHELL implant",
"start": 0,
"end": 53
},
{
"text": "another stream cipher but this time using an eight-byte key",
"start": 74,
"end": 133
}
],
"action": [
... | [] |
CORESHELL has used the same user agent string ('' MSIE 8.0'') that SOURFACE previously used, but in more recent samples CORESHELL uses the default Internet Explorer user agent string obtained from the system. | {
"entities": {}
} | [] |
Figure 11 shows an example POST request. | {
"entities": {}
} | [] |
When Base64 decoded, the POST content looks like this: The key used to encrypt the message is six bytes long and is appended to the end of the message. | {
"entities": {}
} | [] |
In this is example the key would be: 30 ac e5 21 e4 a6. | {
"entities": {}
} | [] |
When the message is decrypted, the resulting plaintext is: The following table contains a breakdown of each of the field's C2 message. | {
"entities": {}
} | [] |
Commands are sent from the C2 server to the CORESHELL backdoor in HTTP responses to the POST requests. | {
"entities": {
"entity": [
{
"text": "Commands",
"start": 0,
"end": 8
},
{
"text": "the C2 server",
"start": 23,
"end": 36
},
{
"text": "the CORESHELL backdoor",
"start": 40,
"end": 62
},
{
"... | [] |
The command is identified by the NULL terminated UNICODE string'' OK'' (O\x00\K\x00\x00\ x00). | {
"entities": {}
} | [] |
The command is Base64 encoded and immediately follows the'' OK'' string. | {
"entities": {}
} | [] |
Figure 12 shows a sample CORESHELL command: The Base64 decoded string is: The following table contains a description of each field in the command message: When the above command'' 10 41 70 41 10 42 33…'' is decrypted using the key'' 01 01 01 01 01 01 01 01'' the following command message is produced: The implant suppor... | {
"entities": {}
} | [] |
The first byte of the command message specifies the command type and is immediately followed by the PE or shellcode to be executed. | {
"entities": {}
} | [] |
In this example the command byte is 04 indicating the following bytes are shellcode. | {
"entities": {}
} | [] |
If the command byte was 01, 02, or 03 the following bytes would be a DLL or EXE that would be written to disk and executed. | {
"entities": {
"entity": [
{
"text": "a DLL or EXE",
"start": 67,
"end": 79
},
{
"text": "disk",
"start": 105,
"end": 109
}
],
"action": [
{
"text": "be written",
"start": 91,
"end": 101
},
{... | [] |
CHOPSTICK is a backdoor that uses a modularized, object-oriented framework written in C++. | {
"entities": {
"entity": [
{
"text": "CHOPSTICK",
"start": 0,
"end": 9
},
{
"text": "a backdoor",
"start": 13,
"end": 23
}
],
"action": [
{
"text": "is",
"start": 10,
"end": 12
}
]
}
} | [] |
This framework allows for a diverse set of capabilities across malware variants sharing a common code base. | {
"entities": {}
} | [] |
CHOPSTICK may communicate with external servers using SMTP or HTTP. | {
"entities": {
"entity": [
{
"text": "CHOPSTICK",
"start": 0,
"end": 9
},
{
"text": "external servers",
"start": 31,
"end": 47
},
{
"text": "SMTP or HTTP",
"start": 54,
"end": 66
}
],
"action": [
... | [] |
This appendix documents variants using HTTP communications. | {
"entities": {}
} | [] |
The first time CHOPSTICK is executed, it may encrypt and store configuration data in the Registry key HKU\S-1-5-19Classes\Software\Microsoft\MediaPlayer\ {E6696105-E63E-4EF1-939E- 15DDD83B669A} \chnnl. | {
"entities": {
"entity": [
{
"text": "it",
"start": 38,
"end": 40
},
{
"text": "configuration data",
"start": 63,
"end": 81
},
{
"text": "the Registry key HKU\\S-1-5-19Classes\\Software\\Microsoft\\MediaPlayer\\ {E6696105-E63E-... | [] |
The user HKU\S-1-5-19 corresponds to the LOCALSERVICE account SID. | {
"entities": {}
} | [] |
The configuration block is encrypted using RC4 encryption. | {
"entities": {
"entity": [
{
"text": "The configuration block",
"start": 0,
"end": 23
},
{
"text": "RC4 encryption",
"start": 43,
"end": 57
}
],
"action": [
{
"text": "is encrypted",
"start": 24,
"end": ... | [] |
The key is a combination of a 50-byte static key and a four-byte salt value randomly generated at runtime. | {
"entities": {}
} | [] |
The static key is derived from opcodes in the backdoor. | {
"entities": {}
} | [] |
CHOPSTICK collects detailed information from the host including the Windows version, CPU architecture, Windows Firewall state, User Account Control (UAC) configuration settings on Windows Vista and above and Internet Explorer settings. | {
"entities": {
"entity": [
{
"text": "CHOPSTICK",
"start": 0,
"end": 9
},
{
"text": "detailed information",
"start": 19,
"end": 39
},
{
"text": "the host",
"start": 45,
"end": 53
},
{
"text":... | [] |
It also tests for the installation of specific security products (Table 9) and applications (Table 10). | {
"entities": {
"entity": [
{
"text": "It",
"start": 0,
"end": 2
},
{
"text": "the installation of specific security products (Table 9) and applications (Table 10)",
"start": 18,
"end": 102
}
],
"action": [
{
"text": "te... | [] |
After collecting host information, CHOPSTICK creates a hidden file that may be named% ALLUSERSPROFILE% \edg6EF885E2.tmp for temporary storage and creates a Windows mailslot with the name'' checkmesv5555''. | {
"entities": {
"action": [
{
"text": "collecting",
"start": 6,
"end": 16
},
{
"text": "creates",
"start": 45,
"end": 52
},
{
"text": "creates",
"start": 146,
"end": 153
}
],
"entity": [
{
... | [] |
Its usage of a Windows mailslot would potentially allow external binaries to write data to the'' checkmesv5555'' mailslot, possibly allowing CHOPSTICK to encrypt and store output from other malware. | {
"entities": {
"entity": [
{
"text": "external binaries",
"start": 56,
"end": 73
},
{
"text": "data",
"start": 83,
"end": 87
},
{
"text": "the'' checkmesv5555'' mailslot",
"start": 91,
"end": 121
},
... | [] |
It creates a thread that records user activity on the host, capturing desktop screenshots in JPEG format, tracks current window focus, collects keystrokes, and scrapes window contents (text, context menus, etc.). | {
"entities": {
"entity": [
{
"text": "It",
"start": 0,
"end": 2
},
{
"text": "a thread",
"start": 11,
"end": 19
},
{
"text": "user activity on the host",
"start": 33,
"end": 58
},
{
"text": "... | [] |
User activity is captured once every 500 milliseconds and logged in an HTML-like format. | {
"entities": {
"entity": [
{
"text": "User activity",
"start": 0,
"end": 13
},
{
"text": "once",
"start": 26,
"end": 30
},
{
"text": "500 milliseconds",
"start": 37,
"end": 53
},
{
"text": "a... | [] |
The thread writes user activity log messages to the'' checkmesv5555'' mailslot in plain text. | {
"entities": {
"entity": [
{
"text": "The thread",
"start": 0,
"end": 10
},
{
"text": "user activity log messages",
"start": 18,
"end": 44
},
{
"text": "the'' checkmesv5555'' mailslot",
"start": 48,
"end": 78
... | [] |
CHOPSTICK reads messages from the mailslot, encrypts them using RC4, and then stores the encrypted message in an edg6EF885E2.tmp temporary file. | {
"entities": {
"entity": [
{
"text": "CHOPSTICK",
"start": 0,
"end": 9
},
{
"text": "messages",
"start": 16,
"end": 24
},
{
"text": "the mailslot",
"start": 30,
"end": 42
},
{
"text": "them",... | [] |
The RC4 encryption used here also uses a 50- byte static key plus four-byte random salt value. | {
"entities": {}
} | [] |
After approximately 60 seconds of execution time, CHOPSTICK begins communicating with one of its C2 servers over HTTP. | {
"entities": {
"entity": [
{
"text": "CHOPSTICK",
"start": 50,
"end": 59
},
{
"text": "one of its C2 servers",
"start": 86,
"end": 107
},
{
"text": "HTTP",
"start": 113,
"end": 117
}
],
"action": [... | [] |
After sending an initial HTTP GET request it uploads the file contents of edg6EF885E2. tmp to the C2 server using HTTP POST requests. | {
"entities": {
"action": [
{
"text": "sending",
"start": 6,
"end": 13
},
{
"text": "uploads",
"start": 45,
"end": 52
}
],
"entity": [
{
"text": "an initial HTTP GET request",
"start": 14,
"end": 41
... | [] |
It does not wait for a response from the server to begin uploading. | {
"entities": {}
} | [] |
Once the contents of edg6EF885E2.tmp are uploaded, CHOPSTICK deletes the file. | {
"entities": {
"entity": [
{
"text": "the contents of edg6EF885E2.tmp",
"start": 5,
"end": 36
},
{
"text": "CHOPSTICK",
"start": 51,
"end": 60
},
{
"text": "the file",
"start": 69,
"end": 77
}
],
"... | [] |
Figure 13 below contains an example of an HTTP POST request uploading a segment from edg6EF885E2.tmp. | {
"entities": {
"entity": [
{
"text": "an HTTP POST request",
"start": 39,
"end": 59
},
{
"text": "a segment from edg6EF885E2.tmp",
"start": 70,
"end": 100
}
],
"action": [
{
"text": "uploading",
"start": 60,
... | [] |
CHOPSTICK uses a URL-safe Base64 encoding, using an alphabet that substitutes'' +'' and''/'' for''-'' and'''', respectively. | {
"entities": {
"entity": [
{
"text": "CHOPSTICK",
"start": 0,
"end": 9
},
{
"text": "a URL-safe Base64 encoding",
"start": 15,
"end": 41
},
{
"text": "an alphabet that substitutes'' +'' and''/'' for''-'' and'''', respectively",... | [] |
Each HTTP request contains multiple Base64 encoded URL parameters, however only one parameter contains information encoded by the malware ('' ai='') and the rest of the URL parameters appear to be randomly generated per request. | {
"entities": {}
} | [] |
CHOPSTICK encrypts an 11-byte sequence in the'' ai='' parameter. | {
"entities": {
"entity": [
{
"text": "CHOPSTICK",
"start": 0,
"end": 9
},
{
"text": "an 11-byte sequence",
"start": 19,
"end": 38
},
{
"text": "the'' ai='' parameter",
"start": 42,
"end": 63
}
],
"... | [] |
The purpose of this parameter appears to be to uniquely identify the particular instance of the backdoor to the C2 server. | {
"entities": {
"action": [
{
"text": "identify",
"start": 56,
"end": 64
}
],
"entity": [
{
"text": "the particular instance of the backdoor",
"start": 65,
"end": 104
},
{
"text": "the C2 server",
"start": 108,
... | [] |
The Base64 encoded text of this parameter begins with a number of randomly generated alphabetical characters presumably intended to prevent people from Base64 decoding the whole string without some knowledge of how the malware family works. | {
"entities": {}
} | [] |
The first four bytes of the message are an XOR key for the remainder of the data. | {
"entities": {}
} | [] |
Once decrypted using the XOR key, an 11-byte sequence is revealed. | {
"entities": {}
} | [] |
The first seven bytes are static, and are hard-coded in CHOPSTICK, while the last four bytes appear to be unique. | {
"entities": {}
} | [] |
The message body of the POST request is also Base64 encoded. | {
"entities": {
"entity": [
{
"text": "The message body of the POST request",
"start": 0,
"end": 36
}
],
"action": [
{
"text": "is also Base64 encoded",
"start": 37,
"end": 59
}
]
}
} | [] |
This encoded string is also prefixed with random characters designed to break the output of a Base64 decode operation on the entire string. | {
"entities": {}
} | [] |
The first 15 bytes of the decoded message body comprise another 11-byte sequence similar to the sequence stored in the'' ai='' parameter as described above. | {
"entities": {}
} | [] |
Decrypting these bytes yields another static seven-byte sequence, followed by four unique bytes. | {
"entities": {}
} | [] |
The remainder of the message body consists of the RC4 encrypted data containing the HTML-formatted user activity log, edg6EF885E2.tmp. | {
"entities": {}
} | [] |
After uploading edg6EF885E2.tmp, CHOPSTICK continues to query its C2 servers for commands using HTTP GET requests. | {
"entities": {
"action": [
{
"text": "uploading",
"start": 6,
"end": 15
},
{
"text": "query",
"start": 56,
"end": 61
}
],
"entity": [
{
"text": "edg6EF885E2.tmp",
"start": 16,
"end": 31
},
{
... | [] |
The malware contains code which allows it to load or memory-map external modules that export the following functions: SendRawPacket, GetRawPacket, InitializeExp, DestroyExp, IsActiveChannel, GetChannelInfo, SetChannelInfo, Run, GetModuleInfo, GiveMessage, and TakeMessage. | {
"entities": {
"entity": [
{
"text": "it",
"start": 39,
"end": 41
},
{
"text": "external modules that export the following functions: SendRawPacket, GetRawPacket, InitializeExp, DestroyExp, IsActiveChannel, GetChannelInfo, SetChannelInfo, Run, GetModuleInfo, Give... | [] |
CHOPSTICK backdoors are compiled within a modularized development framework. | {
"entities": {}
} | [] |
This means that two separate CHOPSTICK backdoors may contain vastly different functionality, depending on which modules were included at compile time. | {
"entities": {}
} | [] |
The modules that are included in an instance of CHOPSTICK may be reported to the C2 server as part of POST messages. | {
"entities": {
"entity": [
{
"text": "The modules that are included in an instance of CHOPSTICK",
"start": 0,
"end": 57
},
{
"text": "the C2 server",
"start": 77,
"end": 90
},
{
"text": "part of POST messages",
"start":... | [] |
Figure 14 includes an example from a CHOPSTICK v1 variant: To decode the POST content, the first step is to remove characters from the Base64 string (the number of characters to remove may vary between different communication channels). | {
"entities": {}
} | [] |
In the example from Figure 14, the number of characters removed is seven. | {
"entities": {}
} | [] |
Once these characters are removed the decoded (but still encrypted) text looks like this: The first two words ('' 72 11'' and'' fd 22'') are checksums that are used to validate the message. | {
"entities": {
"entity": [
{
"text": "The first two words ('' 72 11'' and'' fd 22'')",
"start": 90,
"end": 136
},
{
"text": "the message",
"start": 177,
"end": 188
}
],
"action": [
{
"text": "validate",
"start":... | [] |
The next 4 bytes'' f8 dc 33 9e'' are a salt value that is appended to the end of an RC4 key. | {
"entities": {}
} | [] |
Once decrypted, the message looks like the following: The strings'' V4MGNxZWlvcmhjOG9yZQ'' and'' = < < \xee'' are hardcoded in the implant. | {
"entities": {}
} | [] |
The module information starts at offset 0x20 with the string'' 01 00 00'' and is formatted as follows: The modules included in this CHOPSTICK v1 implant are: Our determination of a CHOPSTICK'' v1'' versus'' v2'' is based on the self-identification of the kernel ID and associated modules. | {
"entities": {}
} | [] |
Compare the list of CHOPSTICK v1 modules in Table 12 with the list of modules in an example CHOPSTICK v2 variant in Table 13: The kernel IDs 0x0001 and 0x0002 indicate different versions. | {
"entities": {}
} | [] |
The corresponding modules in each backdoor also are consistently identified with 0x01 and 0x02, respectively, in the second byte. | {
"entities": {}
} | [] |
In both variants the modules with keystroke log, file system access, and command shell capabilities have the consistent identifiers 0x10, 0x11, and 0x13, respectively, in the first byte. | {
"entities": {}
} | [] |
This suggests that the first byte in the module ID identifies the module type whereas the second byte identifies the kernel version. | {
"entities": {}
} | [] |
The kernel sends commands to each module using its module ID. | {
"entities": {}
} | [] |
The commands that each module understands are likely consistent from build to build. | {
"entities": {}
} | [] |
Table 14 and Table 15 show examples of commands that each module understands. | {
"entities": {}
} | [] |
OLDBAIT is a credential harvester that installs itself in% ALLUSERPROFILE% \\Application Data\ Microsoft\MediaPlayer\updatewindws.exe. | {
"entities": {
"entity": [
{
"text": "OLDBAIT",
"start": 0,
"end": 7
},
{
"text": "a credential harvester",
"start": 11,
"end": 33
},
{
"text": "itself",
"start": 48,
"end": 54
},
{
"text": "... | [] |
There is a missing space in the MediaPlayer directory and the filename is missing the'o' character. | {
"entities": {}
} | [] |
Both the internal strings and logic are obfuscated and are unpacked at startup. | {
"entities": {
"entity": [
{
"text": "Both the internal strings and logic",
"start": 0,
"end": 35
}
],
"action": [
{
"text": "are obfuscated",
"start": 36,
"end": 50
}
]
}
} | [] |
Credentials for the following applications are collected: Both email and HTTP can be used to send out the collected credentials. | {
"entities": {
"entity": [
{
"text": "Credentials for the following applications",
"start": 0,
"end": 42
},
{
"text": "email",
"start": 63,
"end": 68
},
{
"text": "HTTP",
"start": 73,
"end": 77
},
{
... | [] |
Sample HTTP traffic is displayed in Figure 15. | {
"entities": {}
} | [] |
OLDBAIT handles APIs very similarly to SOURFACE and EVILTOSS. | {
"entities": {}
} | [] |
There is a setup routine that loads the imports into a table and all API calls reference an index to this table. | {
"entities": {}
} | [] |
In SOURFACE and EVILTOSS the table is stored in a global variable while in OLDBAIT this table is allocated at runtime and a pointer is passed between functions. | {
"entities": {}
} | [] |
Cyber espionage has been a hot topic through the last years. | {
"entities": {}
} | [] |
Computer attacks known as'' APT'' (Advanced Persistent Threat) have become widely reported and emphasized by the media, damages are now considered as real and strategic trends are moving in cyber defense. | {
"entities": {}
} | [] |
AIRBUS Defence & Space–CyberSecurity unit responds to such attacks for its customers every day, developing a complete range of solutions. | {
"entities": {}
} | [] |
Today, we decided to release publicly information on a specific group of APT attackers known as'' Pitty Tiger''. | {
"entities": {}
} | [] |
This information comes directly from investigations led by our Threat Intelligence. | {
"entities": {}
} | [] |
Pitty Tiger is a group of attackers that have been active since at least 2011. | {
"entities": {}
} | [] |
They have targeted private companies in several sectors, such as defense and telecommunications, but also at least one government. | {
"entities": {}
} | [] |
We have been able to track down this group of attackers and can provide detailed information about them. | {
"entities": {}
} | [] |
We were able to collect and reveal their'' malware arsenal''. | {
"entities": {}
} | [] |
We also analyzed their technical organization. | {
"entities": {}
} | [] |
Our investigations indicate that Pitty Tiger has not used any 0day vulnerability so far, rather they prefer using custom malware, developed for the group's exclusive usage. | {
"entities": {}
} | [] |
Our discoveries indicate that Pitty Tiger is a group of attackers with the ability to stay under the radar, yet still not as mature as other groups of attackers we monitor. | {
"entities": {}
} | [] |
Pitty Tiger is probably not a state-sponsored group of attackers. | {
"entities": {}
} | [] |
They lack the experience and financial support that one would expect from state-sponsored attackers. | {
"entities": {}
} | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.