Datasets:

mrmoor

/

cyber-threat-intelligence

like 8

The network traffic generated by each Trojan uses the HTTP protocol, and despite its use of port 443, is not encrypted with SSL.

As with most fast-spreading malware, antivirus engines will typically begin detecting the files a day or two after the spread has begun.

While we haven’t seen any indication that the spam volume has begun to slow down, we do expect the campaign to wind down in the next 24 hours, but a new campaign will probably be close behind.

WildFire users can rest assured that they’ll be protected from whatever Kuluoz has in-store next.

Sign up to receive the latest news, cyber threat intelligence and research from us Please enter your email address! Please mark, I'm not a robot!

By submitting this form, you agree to our Terms of Use and acknowledge our Privacy Statement.

Following a recent study of apps in the Google Play Store, let’s discuss several security risks caused by the bad certificate management practiced in many Android apps, from social to mobile banking.

All Android apps must be digitally signed with a certificate from the developer.

As described in Google’s official document, the app developer is required to create a keystore with a set of private keys, and then use the private key to generate a signed version of apps.

This key has to be valid for at least 25 years.

These certificates do not have to be generated by a certificate authority and can instead be self-signed.

Because this is simpler and allows the author to retain the private key, the majority of Google store apps use self-signed certificates.

This means it is the developer’s responsibility to keep the private key safe, whether that developer is a 13-year-old or a multi-national company.

As this means the security protecting private keys varies widely, the security risks of bad certificate management cannot be ignored and must be identified, and where necessary, mitigated.

Security researchers are starting to take note and publish on this subject.

For example, BlueBox recently revealed the Fake ID vulnerability, which exploits an app’s certificate verification process within the Android OS.

If they haven’t already

, soon attackers and malware authors will turn their attention to exploiting vulnerabilities surrounding Android app certificates.

When an app is published to the Google Play Store, the certificate information is included within the APK file.

To view the certificate information just open the given APK file as a zip file.

The certificate information is stored within the certificate’s “/META-INF” folder.

You can use keytool or openssl tools to view the certificate information.

An example taken from the popular Angry Birds app is shown in Figure 1.

The certificate fingerprints (circled in red) are what can be used to uniquely identify a certificate.

Figure 1 These digital certificates, self-signed or not, are the keys to updating apps in the Android ecosystem.

It is a primary reason the expiration dates are set so far into the future and developers are able to self-sign certificates.

The only way to update an app is for the developer to sign the update with the same digital certificate originally used to publish the app.

If a developer wants to use a different certificate, they must publish the update separately as a new app.

Furthermore, all Android apps published using the same certificate have a trust relationship between them.

Android allows apps signed by the same certificate to run in the same process and treats them as one single application instead of separate ones.

It also allows multiple apps with the same certificate, if using signature-based permission checks, to expose functionality and exchange code and data amongst themselves.

This is convenient for developers, which is great, but it is also convenient for hackers, which is not.

Losing control of a certificate’s private key, or using an insecure private key, can have severe security consequences.

For example, if an attacker obtained the private key of an app, he or she could create a fake APK file, sign it using the same certificate as the legitimate app, and replace the targeted app with fake app on the device silently using the “Application upgrade” procedure.

In addition, if the attacker can’t create an app with the same name as the targeted app, he or she can still check the “SharedUserId” option.

This allows apps with different package names but signed with the same certificate to share permissions and stored data.

Because of this, app developers should be extremely careful about re-using certificates when signing their apps.

Ideally, an app developer should generate a unique private key for each unique app they post in the Google Play Store.

Unfortunately, during our study of apps posted in the Google Play Store we collected approximately 246,000 Android apps but only 11,681 certificates.

The distribution of the number of apps sharing the same key is shown below.

The X-axis is the number of apps sharing the same certificate.

The Y-axis is the number of certificates.

For example, the number of certificates used by only one app is 1,323.

About 6,925 certificates are used to sign between 6 and 19 different apps.

Figure 2

As we see in this distribution, a lot of developers sign different apps with the same certificate.

We further investigated the following cases:

1. Signing apps with a publicly known private key Many key pairs are well known in the development community.

The most famous set of key pairs would be the key pairs included within the AOSP source files (in Table 1, below).

More key pairs can be found in developer forums and academic research.

Table 1 If one app is signed using the publicly known private keys, it is easy for other apps on the same device to replace this vulnerable app with another APK file, silently with no user knowledge or interaction.

We scanned our inventory of APK files downloaded from the Google Play Store and found at least 87 apps using the “testkey” in Table 1.

According to the Google Play Store, these 87 apps have been downloaded more than 1.6 million times.

For security reasons we are not posting the names of any of these apps.

Under no circumstances should developers ever use private keys that are publicly available, nor should users download them.

However, it isn’t easy for users to know the app they’re downloading is using a compromised private key – the onus for this is squarely on developers.

2. Mobile banking apps sharing one single key Mobile banking apps are particularly sensitive with significant security concerns, which is why we were surprised to discover one certificate was used to sign more than 300 mobile banking apps in the Google Play Store.

This practice is not necessarily dangerous, as long as the developer does not share the key with the various banks that contracted the applications.

We’ve contacted the developer to confirm they have retained sole custody of the keys.

Of course, even with out-sourced application development, app owners should prefer to hold their own key.

Whoever controls the key controls updates for the application forever, and a key shared between applications in this way can never be transferred to a financial institution without compromising the security of all of the other apps signed with it.

The developer is aware of this concern and plans to encourage more of its customers to sign their own applications in the coming year.

In addition to our research, the Baidu Security team in China recently found 23 mobile banking apps sharing the same certificate hosted by a third party app developer and reported the discovery to the CNCERT in China.

3. Third party app developers using the same key for all apps generated for all customers

The app developer industry is booming.

These developers help customers build mobile apps for their businesses easily and quickly.

They serve an important role for the majority of businesses that do not have in-house developers.

Unfortunately, we uncovered some of these developers using the same certificate for every app.

Again, using the same private key is probably due to the convenience in app management.

But as we noted earlier, apps signed by the same certificate can automatically grant sharing relationships amongst themselves.

This means all of the apps created by these developers, regardless of intended use, could be used maliciously.

Table 2 shows select top app developers using the same certificate in signing all their apps.

For security reasons, we have masked the names.

Table 2 Digital certificates are a critical component of the security of Android apps.

Unfortunately, many app developers in the Google Play Store have ignored these concerns in favor of convenience.

While in some cases that may be justified – the app may not contain any important or identifying information – in many of the cases we discovered it is not.

This poses great potential security risks to both app users and app owners.

We encourage developers to reconsider their stance on this issue and where necessary make changes before a significant security event happens.

Sign up to receive the latest news, cyber threat intelligence and research from us Please enter your email address!

Please mark, I'm not a robot! By submitting this form, you agree to our Terms of Use and acknowledge our Privacy Statement.

A backdoor implant is an increasingly common mechanism for maintaining unauthorized access and control over a computer asset.

The terms remote administration tool (RAT) and trojan downloader are often used synonymously with such implants.

Once installed (i.e. implanted on a system), the modern backdoor typically offers much more than simple (i.e. command line) access to a system.

Depending on the backdoor’s specialization and sophistication, it can also capture keystrokes, take screenshots, scrape memory for valuable information, search for files meeting certain criteria, query databases, download files and additional malware, exfiltrate data and files, and even serve as an attack platform.

Effectively, a backdoor implant affects loss of control over a computer asset.

The tangible and intangible impacts of this loss of control vary based on respective backdoor capabilities, and may include the following: leakage of authentication credentials, loss of intellectual property, exposure of sensitive information, negative standing or reputation, and various levels of liability for actions executed on or from the compromised asset.

Recently Palo Alto Networks discovered a backdoor program ( md5: b826fb1253a52a3b53afa3b7543d7694, sha256: 6bedd1b0716fe7632188932451f75295346836545e6d2bfee1b56121e02ca110 ) that is used to control a linux operating system.

This particular linux backdoor will install itself to "/usr/bin/btdaemon" and create a startup service at "/etc/init.d/bluetoothdaemon" with symbolic links so that it will run in any startup mode. The file contents are a simple bash script that runs the original btdaemon file.

The backdoor when run will create threads for each connection listed in its config file. The sample that was caught by our systems contains 3 IP addresses in its config file.

For each IP address the btdaemon service will attempt to make a connection on UDP ports 53, 80, 110, and 443.

Upon successful connection it will send the string "¡°MlCROS0FT|1.2 Apr 26 2014 02:37:05|Linux Kernel Version¡±" and will wait for an "Auth" packet from the server.

If the backdoor receives a packet in the form of a "cmdType|cmdBody" it will check the cmdType list and execute the equivalent instruction. Valid instructions are between 0-9 and there functionality varies depending on the command.

While running the btdaemon process also inspects whether there is an ".IptabLes" or ".IptabLex" local process, and sends back status for monitoring purposes. If the "disablerun" command is sent the backdoor will download a file named "run.txt" from one of the following URLs: The file data is in the format "exe_path_1 | exe_path_2 | ... | exe_path_N". If none of the paths is correct then a "getsetup.rar" file is downloaded and run.

This is an ELF file and there are various encrypted portions within it.

There exist two embedded zlib-encrypted blocks at file offset 0x8C0C0 and 0xE6B40 respectively.

When run if the filename does not include the "IptabLes" string then the data is decrypted, written to disk, and then executed, installing itself as a startup service on the machine and place itself in one of the following locations: The second encrypted block is configuration data, which includes some IP addresses and DNS data which is used when it writes the first decrypted block to a file.

"dns.po888.com|122.228.242.51|119.145.148.56|162.221.13.82".

If the file is run in a path including the "IptabLes" string then it installs itself as a startup service and proceeds into its main loop.

Either path the "getsetup.rar" file takes is meant to ensure that it is installed as a startup service, ensuring persistence. Once the file is running it creates a process identifier (PID) so that only one instance is running at any given time.

The file will connect to an IP and port configured from the configuration data and sends along information that includes the cpu and memory information.