If a phone is encrypted at a platform storage level do I need to encrypt my data stored on it? I am writing a mobile app which would be expected to store sensitive data. It needs to be stored for offline use. I am wondering now that Android and iOS provide encryption at rest do I need to encrypt the data stored in an database within the App.

The main concern would be that the phone could be stolen. What would someone have to do to get the data from the application. Also what state would the phone have to be in, for example turned on, beyond the pin lock screen, logged into the app.

If the data is vulnerable where would I store the encryption key. If someone can root/jailbreak the phone surely the key is compromised and therefore so is the data.

Any help/advice would be really appreciated.

I will first address the various attack vectors possible if the device is on or off and whether full disk encryption (FDE) is on or off. After that, I want to comment about the need for app-level encryption and the capabilities that it offers in your particular scenario.

Here, we assume the attacker has obtained control of the device. Furthermore, we assume that he or she is a well-educated hacker who has the time and resources to extract data out of the device. In real life, you may meet these people (but you may also meet those who are just interested in wiping the data and reselling the device).

Oftentimes, it comes down to the user’s habits that ultimately determine the security of the device. Let me mention a few of them (non-exhaustive).

(a) How does the user unlock his device? Pin code, swype pattern, picture, Touch ID, or none at all? Pin code is the strongest if there are sufficient digits. Swype patterns can be deduced by shining some light onto the phone and tracing out the oil stains. Picture and Touch ID are not fool proof either. See proof of concept videos on YouTube showing Touch ID being hacked.

(b) In addition, is the user conscious of his surroundings when unlocking his device? People may simply peek and memorize the patterns.

(c) How many seconds of standby before the phone automatically locks itself?

(d) Is the user running third party lock screen apps or any other types of apps which may introduce specific security vulnerabilities?

If the phone is unlocked, then the next thing stopping the attacker is any security authentication features built into your specific app (which I cannot comment on since I do not know your implementation). Just imagine you are an attacker now. How easy is it for you to launch up your app and see the data? What if the user recently switched apps? Does switching back to your app afterwards allow you the access the app or not (i.e. is the “login” persistent across app lifecycle states?)

Now, assuming the pin code is secure and the phone is locked at the time of theft, then a manual brute force attack (i.e. the attacker using his fingers to guess the password) is unlikely to work out. However, the attacker may try to do an automatic brute force attack using software tools. Just like ‘password recovery’ or ‘data recovery’ tools out there, you have to connect the phone to the computer and run the recovery tool. In this case, the phone is on. The success of running such forensic tools depends on the following:

(a) Is the device rooted or jail-broken into? Many recovery tools rely on this in order to get superuser rights and security privileges to crack the password or extract the data.

(b) Is developer mode on? Legitimate tools like Android Debug Bridge (adb) may be able to get data out of the phone if developer privileges are enabled. However, in later versions of Android, this should not succeed if the phone is plugged into a completely new PC since authorization must be given on the phone itself (an RSA fingerprint is registered). I am not sure about Apple or iOS.

(c) Is there a malicious or vulnerable third party app already installed in advance that the hacker can communicate with? For example, there may be some bad app that can remotely unlock the victim’s phone once the attacker gets hold of it.

P.S. If you can find a brand new device that can be hacked without the aforementioned conditions, do let Google or Apple know immediately, as this means their default OS implementation is insecure.

Notice that I did not mention FDE as it does not really help prevent the aforementioned attack vectors. If an FDE-enabled device is on at the time of theft, the OS is automatically triggered to do on-the-fly encryption and decryption of the disk sectors that are required by any app anyway. That’s how users can use their apps normally. Similarly, if the attacker’s tools are allowed to run on the phone, then FDE is not going to help, since the OS will cooperate and decrypt the information on-the-fly. In other literature, you may encounter the saying the FDE is mainly there to protect against offline attacks, and not online attacks.

Okay, let’s assume our phone has survived the attacker up to this point, due to our prudent user habits and the fact that we didn’t root and mess up the default security in our device. We have also enabled FDE, so the attacker cannot simply plug the phone in and read out all the data. Even if he transplants the hard disk from one phone to another, the other phone should not be able to read the data since the data is encrypted at rest.

The attacker is left with 2 main options to defeat FDE.

(a) Cold boot attack

(b) Direct memory access (DMA) attack

Now, cold boot attack takes advantage of the encryption key being in volatile memory (RAM). By cooling down the device, the electrical charge stays on for just a bit longer, long enough to plug into some other device/OS and read out the contents of RAM, thereby obtaining the key. In my opinion, this doesn’t seem as easy to do on a phone compared to a desktop with upgradeable memory, given that memory is built together with the motherboard. Also, this is quite impractical as the attacker has to train his skills on a specific hardware phone model.

Cold boot attacks might be mitigated if the phone is switched off at the time of the theft since the key should not be released to memory, however it does not apply to all systems! It ultimately boils down to how Android and Google have implemented their encryption schemes in their operating systems. At least for Android, I know the user has 30 tries to key in the right password upon turning on the phone before Android is booted. This seems to suggest that Android does not release the decryption key until the correct password is given. In a totally separate computing platform, Windows Bitlocker with TPM will release the decryption keys as long as it verifies that the boot partition hasn’t been tampered with; it has nothing to do with the user account credentials that one uses to log into Windows. In other words, shutting down the computer will not make a difference since the attacker can start it up again and the TPM will still release the keys as long as the integrity check passes. Of course, Bitlocker does come with two-factor authentication to counter this problem if you really want it.

In short, I just want to caution that while shutting down the device may seem a good practice, it is not a practical one in the mobile world, and it may or may not mitigate the cold boot attack depending on the details of the implementation.

The next attack used to defeat FDE is the DMA attack. Since Android phones do not come with DMA ports, I think this should not be possible. As for Apple mobile devices, thunderbolt may be exploitable, but I have not researched into this area to give a conclusive answer to this.

Now, let us move on to the real problem where FDE is concerned.

Security experts are happy that Android has finally caught up to Apple in providing default encryption with Lollipop, however, that’s only for new Lollipop devices. FDE is not enabled by default on pre-Lollipop Android devices (even if you upgraded from Kitkat to Lollipop, you still have to turn it on manually). That is a huge number of devices that would persist for the next few years!

Therefore, it may be wise to attempt to have an app-level encryption of our app data for a specific app, as you have alluded to. However, the devil lies in the implementation details. Many “secure” apps on the app store cannot really be trusted unless the source code is available for scrutiny.

One vulnerable implementation I can think of is to ship the app together with the encryption/decryption key. This sounds really convenient for the user – just fire up the app and everything works. No need to keep keying in passwords, since the key is stored somewhere. Okay, so the app data is encrypted and decrypted using the key is stored in plaintext. However, assuming that the device does not have FDE, the attacker can still obtain the key and use it the decrypt the app data (although it may slow him down if we do some obfuscation). This is definitely insecure.

One secure implementation I can refer you to is that of Truecrypt. It is an offline encryption software for computers that is open source. Although it has been a discontinued project as of 2014, experts believe it is still secure and some groups are trying to continue to maintain Truecrypt. It does not store the encryption key on the hard disk. Take a look at the details of its encryption scheme here http://andryou.com/truecrypt/docs/encryption-scheme.php . You can also check out the FAQ to find out more.

I believe you can adapt the scheme to your app. At the cost of convenience, make the user key in a password every time they start your app. The password will be input into a key generating function to generate a long AES key, and the key will persist in RAM until the app closes (like others have mentioned). It is never stored on the hard disk, In this case, it is still vulnerable to Cold Boot and DMA but it does not seem to be likely on mobiles at this point in time.

Another example I can point you to is Lastpass for mobile. It is a secure password manager that has extended its functionality to the mobile space. Maybe you can delve into how they implement their crypto schemes securely and how their app works (if I recall correctly, it also works offline).

Once again I like to stress that encryption does not defeat all attack vectors. If there is a malware running, then that malware could still get hold of the data while the user is using your app. Best weapon to fight this is user education.

Some final comments for now:

If a device is compromised, the user should do a remote wipe of the device. If FDE is enabled, the data is most likely unrecoverable since the key is lost after wiping.

In addition, the user should immediately change all of his passwords for active accounts logged into the compromised device.


Should I close port 80 forever and ever since the 2018 Google-indicated web-security initiatives? I often establish Ubuntu-LAMP environments on which I host a few Drupal web applications that I myself own (I don't provide any hosting services and never done so in the past).

Whenever I establish such an environment, the most fundamental security steps I take are these:

ufw --force enable
ufw allow 22,25,80,443 # All allowed via both TCP/UPD as no restrictions were given;
apt update -y
apt upgrade unattended-upgrades sshguard

After the 2017-2018 W3C/Google (?) reforms regarding browser support in HTTP, requiring or at least encouraging all of us to use TLS encryption confirmed with an SSL certificate for secured HTTP data transfer (HTTPS), I wonder if unsecured HTTP (typically via port 80) is still relevant at all to any of us.

Notes:

Each of my web apps has its own OpenSSL certificate I create with Certbot.
The only web utility I use besides websites is either PHPMyAdmin/PHPMiniAdmin.

My question

Is it okay for me to remove port 80 from ufw allow 22,25,80,443 thus making my system even a tiny bit less "vulnerable"?

Update per answers

Answers recommend redirecting from port 80 to port 443 instead just blocking port 80. I think Certbot creates these redirects automatically so I'm covered if I keep port 80 open as recommended in the answers.

You should not close off port 80. Instead, you should configure your server to redirect HTTP port 80 to HTTPS port 443 in order to use TLS. You can optionally use HSTS (HTTP Strict Transport Security) to tell browsers to remember to only use TLS when connecting to your site in the future.

There is nothing insecure about port 80 being open. Security issues only occur when the web server is serving requests over an unencrypted connection, especially if those requests contain sensitive data. Having port 80 be open and send nothing more than an HTTP redirect is perfectly safe.


Does Windscribe VPN keep logs even when disconnected? I am using (have installed) this VPN on an Android Smart TV.
Does Windscribe (or generally any VPN service) keep traffic logs even when they are disconnected? (Disconnected here means when the 'power-button' like button in the VPN's app is switched off). Some do keep logs when the VPN is on (connected to a server) but do they keep it even when not connected to another server?
These articles say otherwise:

https://windscribe.com/features/no-logs#:~:text=TLDR%3B%20We%20don't%20keep,and%20is%20not%20kept%20historically.
https://privecstasy.com/does-windscribe-keep-logs/
https://vpnpro.com/vpn-basics/does-windscribe-keep-logs/

PS: I am on a free plan of 10GB/month.

Now, we can understand the bandwidth logs because Windscribe actually offers a very useable free plan, which is capped at 10GBs monthly bandwidth. VPN services that offer a capped free tier need to keep track of the amount of data consumed, somehow…

Maybe they could disable it for paying customers?

Theoretically, any software running on your system could monitor socket activity if given the appropriate privileges.
(It's not exactly clear from your question, as it stands, as to what you want an answer to.)
I'll assume that you're asking whether a free VPN provider that you use is logging network activity of other applications running on the same host, even when it is not functioning as a VPN.
On Android, all (or most) traffic is routed through the VPN software, so when it is installed as a VPN it will see all connection attempts. This is because Android routes all packets through the VPN, up to v10 (? not sure when this changed, please feel free to clarify with edit ?), and since v10 some packets (specifically root) can still flow via the underlying network connection and aren't forced through the VPN. TODO ref.
Other software running under the same context can use host tools such as the /proc/ vfs or ss etal. to poll for open sockets and compile a log of these, viz. NetMonitor. Depending on the default configuration, none, some or all of the sockets you currently have open are visible tovia this interface.
The VPN service provider will often make use of some standard VPN software, such as OpenVPN or WireGuard, but they will also offer a convenience application that will instal and configure everything. Often, you as the user will be able to configure this or at least audit the configuration to ensure that no logging is occurring on your device.
From a logical perspective, you must assume that your free VPN provider is logging as much as possible, because there's no way for you (or any of us) to prove the alternate theory. Repeat after me: "there is no such thing as a free VPN".
So, the question that you need to consider, in answer to your question: how does your VPN provider cover the costs of providing you with a "free" VPN?


Combining SCRYPT + a short crc I'm considering using SCRYPT for password storage. (I'm open to PBKDF2 as well, or bcrypt by itself).

The issue is that I don't want this to become a potential point for a DDOS attack, given the overhead of the actual computation.

I was thinking something VERY weak with a lot of collisions as a sanity check first (like CRC8) against the SALT+PASSPHRASE might be a good idea. (then using a wait before returning the failure to guard against timing attack).

This assumes a minimum length of 8, with a 3 of 4 requirement for:

Uppercase Alpha
Lowercase Alpha
Number
Non Alpha-numeric

How much would this would actually reduce the effectiveness of SCRYPT in a brute force attack should data be compromised?

You shouldn't mess with the algorithm like this. I can't think about what the impact of this method is but it does scream insecurity. At the very least, it would allow an attacker to move roughly 256 times as fast since CRC is a relatively simple math function and then of course faster on the database part. You're a few whiteboard coding exercises away from somebody dumping all your passwords if they get DB access.

Instead, issue a token using a cheap function that is rate-limited per client address or client address prefix and require that token with the username and password. That will allow you to rate limit how often you perform the expensive password checking process.


Is TrueCrypt not secure now and should I stop using it? The official TrueCrypt webpage now states:

  WARNING: Using TrueCrypt is not secure as it may contain unfixed security
  issues

  This page exists only to help migrate existing data encrypted by
  TrueCrypt.

  The development of TrueCrypt was ended in 5/2014 after Microsoft
  terminated support of Windows XP. Windows 8/7/Vista and later offer
  integrated support for encrypted disks and virtual disk images. Such
  integrated support is also available on other platforms (click here
  for more information). You should migrate any data encrypted by
  TrueCrypt to encrypted disks or virtual disk images supported on your
  platform.

with detailed instructions for how to migrate to BitLocker below.

Is it an official announcement or just a tricky deface attack?

At this point, it is still unclear. Speculation runs rampant as to whether it's a defacement or official retirement.

That said, it is noteworthy that the latest version of TrueCrypt (before the 7.2 version that's now posted) is over two years old. Also no apparent efforts have been made to support whole-disk encryption on Windows 8, which even older than TrueCrypt 7.1a if you count in the publicly-available pre-release versions of the former.

Many Windows 8 users who used to rely on TrueCrypt are probably already migrated to Bitlocker for whole-disk encryption, so moving the rest of their TrueCrypt-protected data (if they haven't already) is a logical next step anyway. For anyone else, it would probably be preferable to wait until this whole mess is cleared up.

The first phase of the TrueCrypt audit, covering the bootloader and Windows kernel drivers, turned up less than a dozen vulnerabilities - the worst of which were rated as "Medium" severity. The report also said the source code "did not meet expected standards for secure code".

One of their recommendations mentioned:

  Due to lax quality standards, TrueCrypt source is difficult to review and
  maintain. This will make future bugs harder to find and correct.

Another note stated:

  The current required Windows build environment
  depends on outdated build tools and software packages that are hard to get from trustworthy
  sources

All of this, along with the two-year lapse in new releases and lack of full support for the latest OSs, does lend to the easy belief that TrueCrypt's team may indeed be throwing in the towel. If they did choose to do that, then TrueCrypt would in fact become insecure in very much the same way as Windows XP now is - any newly discovered security vulnerabilities would not be patched. A key difference between TrueCrypt and Windows XP however, is that compatible alternatives may still be developed and updated since TrueCrypt is open-source software.

Still, the very sudden and unexpected announcement is definitely worth some amount of skepticism. Until there's been further validation of the news, I would suggest that you not trust anything posted on TrueCrypt's website or SourceForge page - especially not the new "7.2" download.

Update: 2014-05-29 0645Z

Brian Krebs has reported on the issue, and given some sound reasoning as to why this is not likely a hoax. Additionally, he mentions that the people behind IsTrueCryptAuditedYet.com will continue their work despite the software project's current status.

Speculation still runs rampant online of course. However, though the continued anonymity of the TrueCrypt development team makes any undeniably authentic confirmation of their status nigh impossible. Matthew Green made a fair point in this tweet though:

  But more to the point, if the Truecrypt signing key was stolen & and the TC devs can't let us know -- that's reason enough to be cautious.

Really, regardless of the signing key's status specifically, the fact that the TrueCrypt developers can't (or at least so far appear to not even have made any efforts to) issue any separate and authoritative communication to validate what's happened to their website should be enough to raise significant concern. If the TrueCrypt team is calling it quits, it's time to move on and find/make alternatives. If not, their lack of out-of-band response to this incident raises serious questions (more so now than ever) as to how much we can really trust them to maintain the sort of software we want to trust with our most valuable secrets.

Regardless of the status either way, it's probably best to seek alternative solutions. The recommendations on the TrueCrypt site aren't bad in general. However, they fall short of a few features TrueCrypt was known and loved for:

Cross-platform compatibility
Plausible deniability
Hidden partitions
Encrypted container files (you can do this with Bitlocker and VHDs, but it's not nearly as smooth and seamless as with TrueCrypt)

Update: 2014-05-29 1450Z

Jack Daniel has summed up my feelings on the topic quite well now, in a recent tweet:

  So, yeah: hack, troll, ragequit, whatever- silence means TrueCrypt org can't be trusted, so neither can TrueCrypt. Damn.

Update: 2014-05-30 1545Z

GRC has posted claims that the TrueCrypt developers have been heard from, via Steven Barnhart.

https://www.grc.com/misc/truecrypt/truecrypt.htm

If the source can be believed (again, the public anonymity of the TrueCrypt development team makes certain authentication nearly impossible) then TrueCrypt is indeed no longer being actively worked on by the original team. Additionally, the license prevents anyone else from legitimately being allowed to write a new "TrueCrypt" (though it is possible they may be able to fork it under a different name).

One important thing to note, though GRC perhaps is a bit overly dramatic about it and may even be over-stating its value, is that the latest fully-functional version of TrueCrypt (7.1a) is - to public knowledge - still "safe" to use. Until such time as significant, and exploitable, vulnerabilities are discovered there's really no reason to consider 7.1a as inherently any more "unsafe" at the time of the truecrypt.org announcement than it was at any time before.

That said, one must also bear in mind (as noted earlier in this post) that any discovered vulnerabilities in TrueCrypt 7.1a will not be fixed in any future releases. Thus, it is still wise to begin seeking other alternatives. The same holds true here as it does for Windows XP - the only substantial difference being that XP has a much higher profile and will very likely accrue a very long list of un-patchable vulnerabilities (some likely exist already) much more quickly.

The Open Crypto Audit Project has tweeted a link to a "trusted archive" of TrueCrypt versions for those seeking older copies no longer available on truecrypt.org:

https://github.com/DrWhax/truecrypt-archive

Thanks to @Xander for pointing out the GRC article.


Bypass SSL Certificate Pinning using SSL Vulnerablilities I am wondering if it could be possible to sort of "bypass" the certificate pinning protection of Android or iOS using for example the POODLE SSL vulnerability.
According to this blog entry it is possible to extract the SSL encryption key using Padding Oracle attacks.

When I got the key I can decrypt the SSL stream without violating the SSL pinning. I could send my own packets to the server because I can encrypt it with the correct encryption key, right?

The aim would be to change data on the fly in a pinned TLS connection where I got the key for without removing the pinning protection.
Is this possible (theoretically)?

Certificate pinning or public key pinning are rather some protections against malicious/compromised CAs. It can hardly defeat any attack that does not rely on this.

So, attacks like LogJam, DROWN, POODLE, BREACH, BEAST, HeartBleed etc. (just some examples of relevant attacks unrelated to each other) are not defeated by certificate pinning.

Well, pinning might theoretically mitigate some attack of this kind by accident (e.g. it would run some extra allocation that would accidentally prevent attacker gaining access to some interesting part of memory when using HeartBleed), but this is unlikely.

Note that not all attacks give you the same power. For example, POODLE, BREACH and BEAST could allow you reading of some portions of data, but they will never allow you changing the data without being detected. Also, some attacks are applicable only under some specific conditions.

And last but not least, vulnerabilities get fixed over time. Old protocols and ciphersuites get disabled, wrong implementations get fixed, some design issues are workarounded. On the other hand, some systems get updates lately (if they get any), so attacker could be lucky (to the extent the particular vulnerability allows) even with those old vulnerabilities.


allow user to delete individual sessions on account, safe to embed sessions in HTML? I am currently building a web application that allows user to view all active sessions connected to their accounts, and if they want to, delete them individually - like Dropbox

One way I want to implement this is by sending links containing the actual session_key and embed them into the HTML like https://www.example.com/session/delete/SESSION_KEY

Would this be considered good practice or is there a better way to do this?

Would this be considered good practice or is there a better way to do this?

No, this doesn't seem to be ideal.

The biggest problem I see is that you put a session id into the HTML of a page. It is best practice to make session cookies httpOnly to make XSS a bit harder to exploit. By putting the session id into the HTML, you leak that information in case of XSS, thus making httpOnly useless.

This may also be a problem if sensitive data is stored in a session, as someone who hijacked one session or account now has access to all sessions. The impact seems minor, but it doesn't seem ideal and may be a problem depending on the application.

Additionally, you don't have any CSRF protection which - while bad practice in general - doesn't have a security impact in this case as this isn't a very sensitive action and an attacker would need to know the session id, which they don't. Still, it doesn't seem ideal and also violates RESTful.

Finally, it's never a good idea to put sensitive data in a URL, it should instead be submitted via POST as it may otherwise leak in various ways. Again, this is likely not a security issue, as the data is useless as soon as it is used, but it doesn't follow best practices (and may be a problem, eg when the delete didn't work).

I would suggest to use ids that are independent of the actual session id, and to submit them via POST instead.


Cryptography best practices standard I have been searching some standards about cryptography best practices.  I have found some articles and books but no official standard.

Do cryptography best practices standard exist?

The ISO provide standards on many things, including cryptographic procedures: ISO/IEC 19790:2012

I did a quick search on their site for cryptography and found a bunch of others including hash standards and secure financial services standards.

Only downside with ISO is that you often have to pay to get full access to the standards, so sometimes you'll have to do some googling to find a preview.

Hope this helps.


How to globally limit Bluetooth functionality on Android and iPhone I recently got my parents a Bluetooth speaker, and they are very new to the smartphone arena.  What I would like is to disable all of the Bluetooth functionality in their phones except for the ability to play music and place calls through the external speaker.  That way, even if an attacker were able to infiltrate their phone through Bluetooth, they would not have any access to stored files/contacts, etc.  I'm thinking it would be something like the following:

Global Bluetooth Functionality
Allow apps to:
  Play music   On/Off
  Place calls  On/Off
  Share files  On/Off
  Share contacts  On/Off
  ...

For instance, if a legitimate app or an infiltrator tried to share files while the "Share files" global setting was "Off," they would not be able to because the setting is disabled at a global level.  But at the same time, if a speaker was connected and the "Play music" global setting was "On", then it would play fine.  Is there such a feature in Android or iPhone?  They have one of each, so information for either is appreciated.

I have an Android phone and use it to connect to my Bluetooth headphone, Fitbit and car stereo. Normally I turn BT off when I don't use it, and most of the time I don't. So in the car, I turn it on, when I get out, I turn it off. And sometimes I forget to turn it off, and it stays on for hours.

I live in a highly populated area, and whenever I search for bluetooth devices I see ten or more. Never ever have I had a request to make a connection to my phone. Why? Because my phone is only discoverable when I search for a new device. When I do this, I look for the device that I want, connect, and that's it. When I don't see the device, it stops after a while, and the phone is not discoverable anymore.

So I don't see the problem. Other devices won't see your parents Android phone, and probably the iPhone neither. Only when they connect consciously, this can happen.

Maybe my understanding of BT is wrong, but this is how I thought it works.

Teach them how to reconnect to the speaker. They should know the name of the speaker, what to look for. If they don't see it even if they press the connect button on the speaker, they should wait and not try some random device to see if it works.

You could teach them to disable BT if they don't use it, maybe with a homescreen widget.


Is it required to end the session after closing the browser without logging out? Should the Session ID generated after logging in be marked invalid when the user closes the browser without logging out?

Could this be a security flaw? If yes,is it possible to exploit this?

Browsers do not normally listen to any port so there are no port to send the SYN-ACK to. The browser is also often behind a NAT so you cannot even reach any port on the computer the browser is running on except when answering requests. Having an open AJAX request or using web-sockets is of course possible but will be costly in server requirements.

Browsers deletes the session cookies when the browser is closed, if you close it normally and not only kills the process, so the session is permanently lost on the client side when the browser is closed.

The normal option is to set a relatively short session time for your server to close the session when there are no activity on the client. You could also set this really short if javascript is enabled and send a keep-alive request to keep the session open as long as the site is open in the browser.

There are some other means you could use to secure stale sessions, the most simple is to have an onBeforeUnload listener to send a logout request when the visitor leaves your site, this do of course also require that javascript is enabled in the browser. One other thing you could do is to keep track of IP and fingerprint from the browser and connect it to the session so you can test if the browser having the sessionId do not change.

If you have a site with high enough security requirements for you to have to worry about this you should be more concerned about what happen when the user navigate away from the site or close the tab and leaves the browser open


Would limiting write access to a backup directory help protect it from ransomware? I know that this is similar to this question, but I don't believe it's a duplicate.

You have a program that automatically makes regular backups of all your files to a folder or mounted drive.

Let's say you configured your system so that the only process that has write access to that folder/drive is the process that performs the backups.

Would this significantly decrease the likeliness that various ransomware programs would be able to touch the contents of that drive/folder?

Would it at least protect against ransomware programs that run without root/administrator privileges?

Is there any chance at all it could even protect from those that have acquired root/administrator privileges? (Do most ransomware even have that?)

I guess in a really bad scenario, where the ransomware is very cleverly written and equipped, there is nearly always a chance that it could use various ways to get around most things. While that is interesting, I'm mostly interested in a practical situation, and what may actually happen if real life ransomware was confronted with such a situation. (Write access to backup directory is limited to only the process that does backup.)

If this would indeed help protect us, is it relatively easy to set it up on various desktop operating systems?

I'm not only interested in Windows, as there has also been confirmed cases of ransomware on Unix/Unix-like operating systems.

Having a read-only backup directory that is only accessed by a backup user will have a positive impact on the number of ransomware that can destroy/alter your backups. Depending on this solution solely will not fully protect your system.

There's a number of factors regarding ransomware out there, which means that a comprehensive anti-ransomware strategy would have to be used. I did some basic research, and found that while some ransomware would be thwarted by this alone, it's not foolproof. Here some other helpful tips:

Unmount Backups

As long as the files are accessible at the kernel level, there's some chance of a privilege escalation attack that could bypass file permissions. Preferably, your back up should exist on a dedicated machine connected through the network and has to be mounted by the backup user before copying files. This reduces the exposure time for those files to be encrypted.

Network Backups

Don't keep the backup on the same computer as you're using. This is also practical in the sense that when your hard drive crashes, you can go to your backup and restore from there. They do go bad from time to time. I had a hard drive just this year start throwing unreadable sector errors, and it was a backup (but had already been backed up itself before it went bad).

Run As Normal User

Many users decide to run as local administrators (especially Windows users), which makes privilege escalation easier or not necessary. Make sure you're only logged in as root/Administrator to install programs, and run as a normal user at all other times.

Rename Files

Come up with a naming scheme for your file extensions. Most ransomware actually only looks for certain types of files, like pictures, movies, documents, and spreadsheets. Things that you tend to care about. If your backup files have different extensions, most ransomware will happily ignore those files in favor of files it thinks you care about.

Patch Systems

Many ransomware packages depend on exploits in Java, Flash, a specific browser or Operating System, or a driver. Make sure you patch your software as frequently as possible. Drive-by infections are still common, although most drive-by software tends to not use privilege escalation attacks as of late, so simply keeping your software up to date could be a major bonus. This includes third-party software like Magento, Drupal, and so on.

Anti-Virus

Keep an anti-virus program running on your machine, with heuristic matching, if available. Most vendors have learned to tell when a ransomware is up to no good.

Honeypot (?)

I don't know of any off-of-the-shelf products that do this, but you could build a honeypot in your file system in just a few lines of code. Basically, make a folder named "a" in your home directory (/home/a or /Users/a), and write a small program that hooks into the ioctl for that folder. Terminate any program that attempts to read from that directory. Alternatively, just write a daemon that hooks on your backup folder, and terminate any programs that don't have the backup user's id attached to it.

Keep in mind that there's still other ways to mangle your files. In theory, a hypervisor virus could gain control of your hardware and corrupt everything without you even knowing about it, until it was too late. No scheme you could come up with will be 100% foolproof. However, by carefully managing your backups offline, patching regularly, and restricting your user account's privileges, you'll keep the majority of the ransomware in the wild from harming you. This is the same basic strategy you'd use to protect against any other type of virus.


What is the best way to show a (long) number for comparison? How to represent visually a number (like a key or hash) on a screen for visual comparison with another representation of that number on another screen (or another window) in such way that it would be very hard for an adversary (who knows the correct answer) to convince the user that different numbers are equal?

The applications would typically be to display a hash for the purpose of reliable but not to cumbersome user verification.

REMARK:

In the discussion, a "moved goalpost" was described as: "How to display two numbers for comparison when an attacker knows one number and can control the other, and the user isn't willing to look at more than a few characters?"

That's almost the question: the question is how to graphically show these numbers, for the purpose of visual comparison, as users probably will not want to carefully compare more than a few hex digits (or more than the first two).

Display one number directly below the other.  Slowly move the two numbers on top of one another until they overlap.  If they perfectly co-inside, they're the same number.

For bonus points, make one number in yellow, another in blue.  Combined they make green.


Can a webpage track that I have downloaded the page source/webarchive? Can a webpage track that I have downloaded the page source/webarchive?

Specifically on Safari. I understand that accessing a webpage via GET is already traceable back to the requester (me), but if I download the page itself, will it send another request or use a specific header to indicate that I have downloaded it?

There are several methods to track the requests, google analytics is one of the kind.

when you download a web page, obviously it can be tracked by the page owner if he want.
if you download it from web archive or any proxy, it will  be difficult to track as it is from you(your IP), how ever if the page has any analytic scripts etc they will be executed when you download that page from web archive also.


Virtualization / Cloud-Stack fingerprinting from running VM How can the host environment (not just the OS) be identified from a running guest VM. To determine what the underlying host and virtualization stacks being used actually are. I.e. whether there's a VMWare, Cisco, OpenStack or other IaaS solution powering it.

I already know of imvirt and virt-what but they don't provide a lot more info than the basic type of virtualization used, like KVM, Xen, etc.

How can I dig a level deeper and find out more specifics about the underlying stack and products being used. Are there any known reliable fingerprinting approaches?

MAC address look ups don't seem to work
Searching for Hardware vendor names in the output of dmidecode seems not reliable as these names are often customized and branded by the company running the infrastructure.

How reliable are lspciresults like:

00:02.0 VGA compatible controller: VMware SVGA II Adapter
00:03.0 Ethernet controller: Red Hat, Inc Virtio network device
00:04.0 SCSI storage controller: Red Hat, Inc Virtio block device

Does this mean that VMWare on Red Hat is used? Or does it mean nothing at all as these virtual devices can be used by anyone?

Thanks

PS: There is a related question here but quite old (from 08) and not quite the same: https://stackoverflow.com/questions/154163/detect-virtualized-os-from-an-application

About trying to identify the virtualization stack, a KVM host can be identified by issuing a combination of some commands like these:
dmesg |grep KVM
lscpu |grep Hypervisor (it should return Hypervisor vendor: KVM)

You can even try to fingerprint the host with nmap with OS detection option (nmap -O host_to_check_ip), it can give you some information about the MAC address.

I think the same can be done to try to identify VMware hosts and other kind of hypervisors too.


Special sqlmap injection I'm currently pentesting my friends website. I found an SQL injection with acunetix' help:

- URL encoded GET input for was set to 1#####
Error message found:
supplied argument is not a valid MySQL result

So I tried running a normal sqlmap:

./sqlmap.py -u "http://www.example.com/ajax.php?div=content&for=1*&page=1&sort=4&show=1&what=topic" --threads=25

Output:

  [11:16:31] [WARNING] URI parameter '#1*' is not injectable [11:16:31]
  [CRITICAL] all tested parameters appear to be not injectable. Try to
  increase '--level'/'--risk' values to perform more tests. Also, you
  can try to rerun by providing either a valid value for option
  '--string' (or '--regexp'). If you suspect that there is some kind of
  protection mechanism involved (e.g. WAF) maybe you could retry with an
  option '--tamper' (e.g. '--tamper=space2comment')

So I need a way to include those #'s (for=1%00%c0%a7%c0%a2)
Tried --string and --suffix but didn't do the job. Maybe there's a tamper for this?


Security JWT and CSRF TOKEN question Lets assume that i have create website which in every request to API lets say send JWT token and CSRF token. So let's create case like that:

I'm logged in to user A and make ajax request to API with JWT and CSRF token. I go to networking and read this tokens and copy them.

Next i go to eg another server or injecting progam and inject this JWT and CSRF token. Will i will be able to recieve data ? If yes/no why ? I need to add that cors is disabled

Looking forward for replies. Thank You very much and regards

It sounds like you aren't clear on what how these tokens are used.

A JWT is a type of "Bearer token": this is a token created by a particular server and given to a user to keep secret.  The user can later show this token to the server to prove their identity.

It is very similar to a password - you send your password to a website, and the server thinks "this person knows the password, so it must be the correct user".  However, sending your StackExchange password to Yahoo Mail won't let you log in, because Yahoo won't recognise the password for an unrelated website.  However, if you take your password/token and use it in a different browser for StackExchange, then it will still let you in - which makes sense, because it is your password/token.

A CSRF token is a different type of token, used to prevent a different attack, but it will still only work for the servers that recognise it, much like a password or a JWT / Bearer token.


Seeing outboud connections to random domains, how do I isolate the app responsible? Last night I loaded up Fiddler2 to do a little debugging and I saw three connections to domains like

hghefhhig

How can I go about isolating the application responsible?

I was thinking possibly logging all outbound connections to domains that do not contain a "."

Any ideas are greatly appreciated =]

PS: The domains did not resolve, if they had, I would be freaking out.

Jeff

Fiddler does show which process the connections originate from.


Should I contact the manufacturer if their product allows access to other users' location information? I recently purchased a satellite communicator that allows me to send a map of my location to friends and family while I'm hiking in the wilderness.

While testing out my product, I noticed that the url was constructed as so:

http://www.example.com/mylocation/?id=YYYYY/XX.XXXXN/XX.XXXXW

Where Xs are digits that are part of a physical latitude/longitude and the Ys are part of a 5 character alphanumeric ID.

Being curious, I truncated the latitude/longitude part of the URL and changed the ID by one character.

http://www.example.com/mylocation/?id=YYYYZ

By doing this, I could then see a different user's:

physical latitude/longitude location on a map
device name (whatever they chose to call it; most people have something like "Harry's GPS")
custom pre-set message used while sending their location, if they have one set (ex: "Checking in - I'm safe.")

My question is, does this present a security flaw, and should the company be alerted about this?

My argument for contacting the company would be that seeing other users' physical locations is a blatant flaw; however, that's the entire point of the product - to easily share your location with your family/friends. I also can't see whom the device actually belongs to (name, phone number, username, email, etc.), so the location data is anonymised as far as I can tell.

Yes, you should notify the problem to the company - with caution.
Update: a shorter, very complete answer was supplied by @crovers. But if you have patience...
...the problem here is not simply the possibility of tracking J. Random Stranger, but rather that:

once your ID has been given to someone, apparently you cannot take it back and it does not expire. That person can now follow you everywhere (think "overly attached girlfriend"). Also, that ID may leak. Emails get forwarded by mistake and sometimes the little, easily overseen ... glyph in mail programs covers lots of sensitive information.

you don't even need to give it to me. If the IDs are sequential [as commented by @crovers], I can tabulate all of them in very little time, check their position, and easily single out those five or six that are near enough to the position I know you might be in. Tomorrow, other five or six will be near enough a different place you're now in; of those five, maybe two were in the original five, so you must be one of those two. In a comparatively little time I've narrowed my candidates to one: I now have your ID and can stalk you, and you are none the wiser.

I may even not know you. The ID can be used to prank total strangers. I just googled a bit and found a couple thousand Facebook users that boasted of their new (NAME OF GPS-RELATED GADGET). I used a very well known brand, so your gadget will have maybe only one hundred people that I can discover easily. A full half of those, I'm confident, will routinely post pictures about where they are (does Facebook purge EXIF GPS information?).
In a very little while, one of them that caught my fancy might receive a message stating "How's the weather in Old Nowhereville?" even if he (or she) never said anything to anyone about where he (or she) was, nor even posted anything anywhere. Such pranks - and knowing that some total stranger is apparently interested in you, and always seems to know where you are - can totally ruin your day.
And they can totally ruin the company's day, if some pranked people get convinced that their GPS can somehow be "hacked remotely", even if, as in this case, that's not what's happening at all. Yes, I have a sick mind - but I'm not the only one, so you might want to point the company's people to this page - and, to restate another very good point made by @crovers and Arminius, do so anonymously. The potential damage to them is huge, and you're doing them a big favor by pointing this to them. But some companies might have a (knee-)jerk reaction and try to bully you into silence believing this solves something (or even solves the matter entirely); Nobel Prize Richard P. Feynman's "vulnerability disclosure" story makes for a hilarious reading ("That was his solution: I was the danger!").

You're actually helping them.

trust me, lots and lots of people would do exactly what you did when seeing "id=XXXXX" in a URL. I  would have done it. Depending on the gadget's popularity, I'd wager many others will already have done so. So it's not like you're unleashing a zombie apocalypse over someone which otherwise would have remained safe - you'll probaby simply be the first to have had the conscience of telling them they are not safe at all. Because that's significantly rarer than having the curiosity of changing a ID.

It totally hadn't to be like this.
It is trivially simple, from the company's point of view, to fix this by allowing each user to regenerate a different secret ID on demand any time they choose. And even set an expiration date. And they still could do it now.
A very quick fix could be to proxy their website through a simple filter, connected with a database.
Your new URL is, say, http://www.example.com/mylocation/?id=22b255b332474ae3e7f008cc50ebe3e0&...
or one could translate that to "true.pony.pile.main.jazz.call.mine.soft.pink.rake.jane" to get something more easily remembered or dictated over a phone.
the first four words are somewhat connected to "correct horse battery staple".
The proxy checks in a database and finds that 22b255b332474ae3e7f008cc50ebe3e0 is a valid ID, and is associated to "real" (or "old") id 12345, so it transforms the URL by simply replacing the ID with 12345, sends the request to the true, hidden website, gets the page back, rewrites any 12345's with the original 22b2... stuff, and hey presto!, the external user can see where you are, same page as before, but he has no way of knowing that the true ID is 12345 (and, even if he knew, he'd have no way of getting it through to the system, which now only accepts hashes).
But now, user 12345 can have as many IDs active as the company wants (or sells!), and give one to his mom, one to his SO, and so on. One ID leaks, or he breaks up with his friend -- he invalidates that one ID. It also becomes possible to know how many accesses there have been to each ID, so the snooping can be two-way. Possibly for premium users only :-D. For some IDs, the website may even release randomized information, or low-precision GPS coordinates.
And if you wanted to guess at random a valid ID - well, there are some 2128 of those. If each customer had one hundred disposable IDs (say 27), and the company had one billion customers (say 230), there would still be approximately one possibility over 290 to get a valid ID by trying at random. If that's too little (or if my math happened to be a bit askew), there are larger hashes too.
And the old ID no longer works since you can't reach the original server without the ID you supply getting hashed.
Given the reasonable implementation cost (a couple day's worth for one developer and one QA engineer, and I'm padding heavily), I'm a bit baffled that this wasn't designed in from the start.


How can I use certificates to secure my webservices? What is available to javascript? I have a few web services that are accessed over public wifi connections and I think it would be a good idea to issue certificates to encrypt data, prevent MITM, and invalid impersonation (beyond what HTTPS provides).

Most of the client interaction I've seen with certificates involves a "fat client" and not so much with web sessions or javascript.

That being said,

What kind of standards should my javascript clients and web clients?
Will traditional clients be able to use the same web interface, or is a different standard appropriate (WS-*)?

If you want to secure WS'es with fat client (standalone app, mobile app, other server) you can use WS-Security protocols suite. It's widely used in SOA's and other enterprise deployments. It provides strong auth, and some security and anti-replay solutions in standarized fasion.

But if you wan't to use JS the you would have to stick with authentication token and ssl. I guess.


Why aren't applications sandboxed in Windows? Sandboxing seem to be a way to restrict what an application can do. Today, I don't have much control of what my applications do with my computer. It feels more secure to use JavaScript based web applications than run native applications on my Windows system.

What are the reasons to why applications aren't sandboxed by default on Windows?

See also How can I restrict what an application can do with my computer?

I don't know much about Windows API programming, but a few functions seem to be scary, if allowed by an arbitrary program, such as:

VirtualProtectEx function
GetKeyboardState function
WriteProcessMemory function

Oh, but they are, good sir! Sandboxing is not a new concept and has been around since the 1980s; however, as you have probably gathered, the limits of those types of sandboxing have been pushed to the point from a security point of view they look inadequate.

About sandboxing and the permissions model

Let me explain. When your computer boots, it starts up in 16-bit real mode for compatibility reasons (i.e. so you can still run DOS). To cut to the chase, you basically switch to 32-bit protected mode or 64-bit long mode, which are slightly different, but also reasonably similar. At this point your x86-based CPU is in supervisor mode and must set up and handle things like page faults and sysenter or software interrupts so you can do system calls. Skip a few million lines of code to launch all your hardware devices and tada, your first process runs.

Your process, as you may know, is created knowing nothing about the underlying system memory - it sees virtual memory. It is also created running in normal mode (called ring 3) which means it can't do things like set interrupt handlers or alter page flags. In short, it can't see other processes' existence (it "believes" it has full run of the computer) except by asking the operating system.

So, your average every day process is sandboxed, after a fashion. Now, all processes* must ask the operating system to do things, including Administrator ones. What decides whether they can is... the operating system.

Currently, this is mostly done via user permissions. Processes inherit the context of the user they are running as; so a process run as an Administrator user can do anything because the Windows kernel will check its permissions, find out it is an administrator and say "yes, ok" (with exceptions; user mode processes can't technically do certain things but they can load kernel mode processes (e.g. drivers) that can). Likewise, on Linux, root is assumed to be able to do anything.

So the current model (and now I finally get to your question) says that processes inherit and can do exactly what your user can do.

Now this might be a reasonable assumption, except that you might want to have a sensitive word document on your disk and run a web browser. As a result of the fact that your web browser can do anything you the user can do, the fact that you can read the document using word means the web browser could, if it wanted to, as well and there exists no provisions to prevent this.

There are designs for more invasive, more sandboxed permissions systems for operating systems, such as MAC. These systems all propose variants of the idea that each process is additionally constrained in what it can do; so your web browser is allowed only to access the network, temporary storage and the downloads folder. I asked for reasons for their lack of uptake here and the general consensus appears to be complexity is a major factor. People understand the current model well, even if that understanding is simply "I run as Administrator to prevent all the annoying dialogs". MAC systems are inherently complicated; you need knowledge of what a process should be able to do to constrain it.

The much maligned much hated security-failure Windows Vista actually introduced, amongst a slew of other excellent security features and a rebuild of certain OS components, Mandatory Integrity Controls. These go some way to building MAC-type components into Windows.

So, tl;dr for the general question: MAC is hard to understand and complicated to implement.

About those API calls

Now, onto scary API calls:

VirtualProtectEx: Changes the protection on a region of committed pages in the virtual address space of a specified process
WriteProcessMemory: Writes data to an area of memory in a specified process. The entire area to be written to must be accessible or the operation fails.

Take a note of the notes on the bottom of the latter one:

  Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged.

These all-caps values are constants which represent Windows permissions - you can only call that function if you have or can obtain those permissions on a process. On the former function, note:

  The handle must have the PROCESS_VM_OPERATION access right. For more information, see Process Security and Access Rights.

The full set of process rights is discussed here. Now, most crucial of all to note is that you need SeDebugPrivilege. The details of this are best explained on the Old New Thing:

  By default, users can debug only processes that they own. In order to debug processes owned by other users, you have to possess the SeDebugPrivilege privilege. But don't grant this privilege casually, because once you do, you gave away farm.

So yes, it is possible for you as a user to call these functions and debug processes, but only ones you already own. As the permissions model allows any process you have to do anything your user (including processes you have running) can do, this is expected. Debugging your own processes is a reasonable activity, although yes, it could be used for ill - this ability is the crux of the issue with the current model.

Now, onto GetKeyboardState:

  An application can call this function to retrieve the current status of all the virtual keys. The status changes as a thread removes keyboard messages from its message queue.

All windows processes running GUIs have a message queue of events that have happened to them. What this says is that you can retrieve the keyboard state of your process after you have read an event. However, note that:

  The status does not change as keyboard messages are posted to the thread's message queue, nor does it change as keyboard messages are posted to or retrieved from message queues of other threads. (Exception: Threads that are connected through AttachThreadInput share the same keyboard state.)

So, yes, you can use AttachThreadInput to hook other processes inputs. There is a workaround for this - see How does Windows Secure Desktop Mode Work?. Essentially, Windows supports multiple desktops and by using these you make it impossible to AttachThreadInput onto them.

tl;dr these functions combined with the current security model do represent a risk and a limitation of the current model, especially to the data and processes of the current user; however, there are levels of security protection in place for your system as a whole provided you are not running as an Administrator user!


Anonymity of Bitcoin I just asked myself that when you have bitcoin network, which is as we know "pseudo" anonym. Because of the transaction logs of the network (which are afaik endless), it seems that transactions are traceable. But my question is how traceable am i when i am using a bitcoin client with something like tor or other networks like i2p or such.

Well there are a few possibilities here. First of all when you are purchassing something with Bitcoin, you have to send that "something" to your house or email address. If it's non-physical you might be able to stay anonymous if you create your account behind Tor.

There are also a number of services that are speciliazed in making it harder to follow transactions. What they do is:

you pay them on address X which is created ad hoc
they use address Y to pay you on a new address, minus some transaction fees for their service
looking at your account someone can still see you sent money to a certain address of such a service, but they can't trace to where the service sent your money off to (which is your secret wallet).

This is not foolproof though as someone might try to figure out all addresses and cross-reference the amounts and wallet addresses.


php security courses I got asked today by my boss if I wanted to do some php security courses, however I am not even sure other than the zend securing php applications course if any exist could any one provide any links or details, also would it be worth looking at CISSP ?

Thank's in advance

This is the only PHP security course that I've heard of. I know of the author (Johannes Ullrich) and he's excellent but then he's not always the instructor. Here's a complete list of SANS web app sec courses since that's the topic you're essentially asking about.

Regarding CISSP, I decided not to go for it, it just wasn't for me. I felt it was too general and too high-level so I went and did a few SANS courses and certifications. SANS courses are much more technical and well-respected, though they do seem more popular in the US than say, Europe. I've heard mixed reports about CISSP but I'm not in a position to comment further.

There's loads of courses and certs out there so you need to have think about what you want to do, what technology you'd like to work with etc and go from there.

I'm not a huge fan of vendor courses/certifications so try to stick to something independent and that's useful across multiple jobs/industries.


Dictionary attack knowing the cipher Let's suppose I know a website is using BCrypt with salts and the default round of 10.
Can I do a dictionary attack by hashing all the words using BCrypt with the same parameters?

Yes, you can.  bcrypt, (and other similarly slow password hashing functions) aren't designed to make this impossible, but only to make it prohibitively expensive.   Weak passwords are still susceptible to being discovered, but the amount of work an attacker needs to do goes up substantially, and compared to a fast hashing function, much weaker passwords become infeasible to crack due to the extra work required for each guess.


How protective should we be of an SSL client certificate? We've got an application where the database connection requires an SSL client certificate. How protective do we need to be of this certificate? What are the implications if someone else gets it?

I understand roughly how public-private key encryption works, but I don't know which key the certificate contains.

Generally speaking, a client certificate is used to provide authentication (as opposed to encryption).  You need to ensure that the private key and passphrase (if any) are protected.  If someone gets them, then they can authenticate to the database using that certificate credential.  If your application instead required a password to access the database, then the equivalent would be someone else knowing that password.

Without knowing what app documentation you're looking at, I'll go out on a limb and say that the "client certificate" means the private key and signed certificate; the signed certificate includes as a matter of course the public key.  It's the private key that you really need to protect.


Extensions and Modules and Packages, Oh My! How do you know if extensions (e.g., Code, Chrome, Firefox), modules (e.g., PowerShell), or packages (e.g., Python, R) are not malicious? How can you control or monitor that in an environment? Stuff like this get out of hand quickly!

I can only think that strong application whitelisting would control this, or have a security policy for these application extras. (Is there a proper term for that instead of using application extras?)

I'm having trouble finding what Microsoft's stance is for PowerShell modules and the Code Marketplace? How are they making sure that those extras aren't malicious? How is any business making sure those extras aren't malicious?

The safest way is to vet it yourself by reading the source code before installing and the changes before each update. You can find guides to read each browser's extensions/addons source code here:

Chrome
Firefox

As for Visual Studio, you can choose only the extensions which are open source and read their linked repository from their marketplace page.

Regarding security policies, I believe most big companies have a policy for vetting each extension being installed in any service. You'll need an application or infrastructure security team for that.


What tools are needed to view or detect covert messages in a 60 fps video? The eye can't detect changes in a frame greater than 60 FPS. Similar to this scene in Fight Club, a QR code equivalent is used in pairing the Apple Watch with the iPhone

Without knowing that the iWatch gives off a secret code only the iPhone can read, how can one detect such embedded data?

Computerphile vid about steganography
Edit-
The video covers jpeg steganography where data is meant to be hidden in an image by changing the least significant bit or values in the discrete cosine transform used to compress to jpeg. the idea is to have the image not be perceptibly altered and still contain as much information as possible.
From the article you mention, instead of hiding the alterations they make to the images, their goal is to have easily perceptible changes that are cyclic, and to our eyes average to what we expect from the rest of the frame.
-Edit

I'd imagine you get a camera that can shoot above 120Hz and look for big jumps in chrominance in adjacent frames.
Edit-

chrominance is going to be the color information from the image as opposed to the intensity.
changes in intensity are more easily detected so would probably be a less likely to be used for this.
It may be able to see if just slowed down.
and i guess instead of looking at jumps in chrominance better would be to just subtract adjacent frames into a new series of images and then just look for the frames with much less black than the other ones.
-Edit


Router reboots when using Nmap When I scan an external IP address with Nmap my router always reboots itself, sometimes I even have to manually restart it by using the power switch.

The command I usually use is:

nmap -p 1-65535 -T4 -A -v -Pn *IP address*

I'm using an Asus RT-AC66U with the latest firmware. I have also tried using the Asuswrt-Merlin firmware but the result is still the same.

Has anyone else experienced this problem and solved it?

You are probably exhausting the router's resources, primarily the NAT table. Every outgoing connection maps your scanning machine's private IP address and source port onto a new source port on the router's public IP address. Since there are more IP address + source port combinations than there are source  ports on the single public IP, the router has to do extra work to avoid collisions. Ideally, this would not cause a reboot or a crash, but home routers are not ideal pieces of equipment.

The easiest way to slow your scan down to something your router can handle would be to change -T4 to -T3 (the default). If that doesn't work, continue reducing the timing options until you get a good result. The other thing that can help if you are scanning more than one known-alive IP address is to not use -Pn.


How to store Personal Access Token securely on shared machine We have a shared machine in the office, used for demo'ing our product.
I want to be able to fetch the latest code from Github.
We have 2FA enabled, so I can't use my login password for https operations.
I can use a Personal Access Token as the password.
What is the best way to store this Personal Access Token on the shared machine, so that
A) I can access it, but no one else can.
B) It's easy to get into the clipboard so that I can paste it into the password prompt?

Use a password manager.

A) I can access it, but no one else can.

This is quite tricky on a shared machine. Using a password manager does ensure nobody will be able to access the stored token as it will be encrypted, but malware may still be able to keylog your password manager's master password when you enter it. But in the case of malware, the token can already be stolen when you copy it to clipboard. So, to minimize possible damage, make sure the scope of the token is limited to only those permissions that you need while giving the demo


Would it be considered good practice to make the salt for a password the hash of the user's username? I heard it was good practice to have each user have a unique salt, when I'm hashing a user's password with a salt. My question is, can I make my salt a hash of the user's username? Ex.

$username_hash = hash($username);
$pwd_hash = hash($username_hash + $password);

Would something like that be considered acceptable? And more importantly, secure?

Edit:

I know I could do

    $pwd_hash = hash($username + $password);

But if I do that it doesn't protect from rainbow tables, although a hash of the username would.

No.

Remember that people tend to reuse passwords from service to service. If two systems use your scheme and someone uses the same username and password on both systems, then they will end up with the same hash in both cases.

Salts aren't secret, and technically the randomness requirement on them isn't as strong as what is required for cryptographic keys, it is best to generate them the same what that you would generate keys just to avoid this and other sorts of mistakes that people make when creating salts.


What precautions should I take when creating users that will be used by applications and not by people? I have some applications that need to access to a webservices bus. Own applications that access to the bus authenticate using a webservice on that bus but in this case I need that third party applications access some webservices in the bus.

These third party applications need to authenticate in a LDAP (Oracle OID). I need to create a user and a password for each application that needs to authenticate.

Is there a more secure way to authenticate these third party applications in the webservices bus?

What precautions should I take when creating these users in the OID?

What precautions should I take when creating users that will be used by applications and not by people?

Identification and tracking become important but surprisingly difficult.

First, tag the accounts in the directory so you can identify them as non-user IDs.

Each non-user account needs to be associated with an account owner, someone responsible for securing the system it accesses.  Store the owner's identity in the non-user ID's directory entry, so if you go hunting these down later, you know who should be contacted.  Remember that owners come and go with employee promotions, turnover, etc., so you might need a department or other organizational tag to go with the employee ID.  Group membership can help here.  Also, as employees leave, their directory accounts may be deleted, rendering an unknown ID useless - a name is at least someone other people can help you track down.

It may also be helpful to know what machine the accounts are associated with.  Keep that information in your directory, too.

If you have a formal request system, where people enter their requirements for requesting the account, the machine, etc., I'd store the request number in the directory entry.  But keep in mind that request tracking systems can be changed, and that information associated with tracking numbers issued 5 years ago may no longer be available.  I recommend you still keep the owner and machine info on the record, too.

If you don't already have a formal review process for your accounts, consider that when you do implement one, you'll have a big pile of non-user accounts in your directory.  This data will help you identify the reviewers (the system owners should review these for appropriateness on a periodic basis.)  Consider keeping the review data with the record; you may even want to keep 'last reviewed on/by' information in the directory to provide to auditors.

The main reason to keep this information is in case of a compromise.  During the response phase, you need to be able to rapidly identify the people associated with the account so you can change the passwords, scan the systems, and track them down quickly, with a minimum of effort.  Keep in mind that you may need to do this activity without alerting the system owners, at least while the investigation is active.  You may also need to provide review information to investigators.  It's a sad reality that the compromise may originate from an internal source.

To answer the rest of your question, you should generate a lengthy password, using a cryptographically strong password generator (not javascript's random()).  If you can assign these accounts and passwords without involving humans, using a password management tool, that's even better.  There are commercial systems that tie into ldap servers to do much of this (since you're an Oracle shop, you should check with your account rep because they sell such a system.)


Why does Windows 7 remove Authenticated Users from file permissions when a folder is shared? When I try to share a folder using the share tab in file properties, if I go back and remove sharing options from the Share tab, it also affects the Security tab, removing inheritance of permissions from the parent and also removing the Authenticated Users permission, causing the little lock icon on the folder to appear.

So I think I partially understand it, but at the same time, not really. I get that sharing a folder changes sharing permissions, but I'm not entirely sure why it is changing local permissions. I'm not smart enough to figure this out on my own, sorry.

If you use the Share... button Windows will push the share rights on to the file permissions. Period!

Use Advanced Sharing... button if you want to separate the share permissions from the file permissions.


No limit of characters in name field - Any risk? I want to know what security vulnerabilities could have a website that in the name field there is no character limitation. so there could be 100 characters or 10k. My first idea is that it can could lead to DoS to the platform and other users but is that true? are other issues to be concern?

It is not really relevant if there is a size limit in the HTML form fields. Such size limits are only a client side restriction which is also only enforced by some clients (browsers). As with other checks done only at the client-side it is easy to write a client which ignores such restrictions.

All what is relevant in this case is how the submitted data are handled on the server side and this can not be determined just from looking at the HTML at the client side.


Email Policy Question - Unsure what to be looking at I'm a bit unsure how to answer this question. I've looked online however I'm unsure if I'm answering the right way.

  Your organisation has an e-mail server that processes sensitive emails
  from senior management and important clients. What should be included
  in the security policy for the email server?

I was looking at secure the chat mail, secure the transmission, etc. Would that be the correct way to answer it?

Policy statements need to be tied to risks. Each policy statement is a control to reduce a risk to the organisation.

So, in this scenario, you need to identify the risks to the organisation and to determine what high-level controls should be in place to reduce those risks.

A good policy needs to make a difference between a policy ("strategy") and procedures ("tactics"). A policy should not specify how to do something, but what the approach is to gain a desired outcome. That way the policy can be applied no matter what the technology is. This can be a very difficult line to walk and many policies blur this line in practice.

So, from a high-level, outcome-based perspective, how should the organisation approach the email server given that it processes sensitive emails?

There are many corporate email policies online for you to use as inspiration. Writing information security policies is an art and getting practice is a very good thing.


How does sensitive information leak assist in exploit development? According to this bug report, the first vulnerability can leak sensitive information.

But since it doesn't mention what information to leak, I guess it would be the stack? And how could this help in exploit development?

Usually, that kind of leak (reading a string which was not NULL-terminated) results in reading what happens to reside in RAM just after the string. Then this depends on where the string is. If the string is stack-allocated, then this discloses part of the stack (since stacks "grow down", this will explore local variables of callers of the current function). If the string is heap-allocated, then the reading will overflow in adjacent blocks, which can be about anything, depending on all previous allocations since last boot, so this is rather unpredictable.

There are some high-value targets in the kernel (e.g. encryption keys for in-kernel cryptographic operations). These targets can be in local variables, block-allocated objects... it really depends on the context. Simply reading the local stack can help a lot in fine tuning a buffer overflow exploit (a non-tuned buffer overflow leads to a crash, a tuned buffer overflow can lead to arbitrary code execution).

Most peeks at the kernel memory won't reveal anything of value, because 99.9% (at least) of memory used by some code (be it the kernel or some application) is not really confidential and could be revealed with no ill effect. However, it is very hard to precisely locate the remaining 0.1%: guaranteeing that a given piece of information is not sensitive is nigh infeasible in the general case. So it is safest to consider such information leak vulnerabilities as "potentially serious", and fix them.


Methods for uploading shell to a website I know shells can be uploaded via sql injection, remote file inclusion and exploiting the web app's own upload mechanism. Are there any other ways to upload a shell to a website and be able to execute commands?

You don't just have to be concerned by the ability for the user to upload a shell, but also by what exploitation of your code could achieve the same thing. There are many, many websites out there which use PHP commands such as exec() on user submitted data (from $_POST or $_GET) without doing any kind of validation on them. These issues can be combated by properly escaping untrusted information before using it on the command line, or refactoring to avoid having to use the system shell at all (perhaps such that you can enable Safe Mode and disable dangerous functions such as these in production).

Another method in addition to those you mentioned in terms of actual malicious filed upload is the HTTP PUT request.


Uploading pfx certificate to Azure In order to use SSL with a custom domain in Azure Websites you must upload a pfx file with your certificate and private key to Azure.  What are the ramifications of trusting Azure with the private key, especially if I want to use a wildcard certificate on multiple sites?

http://azure.microsoft.com/en-us/documentation/articles/web-sites-configure-ssl-certificate/

The primary ramification is that the security of your private SSL/TLS key is ultimately out of your control.

Technically, you could use a wildcard certificate, or a multiple domain certificate (Subject Alternative Name, or SAN, certificate).

However; if you use a wildcard or SAN certificate, then the security of all of your servers is tied to the security of that private key (which is ultimately out of your control).

If some of those protected servers are on your own private/office network (meaning you are using the same SSL/TLS key on both your Azure-hosted server[s] and your server[s] at your office), then the security of your office is tied to the security of that private key (which is ultimately out of your control).

Ultimately, that private key is out of your control once you hand it over to Azure. They may do a very good job of securing it in a general sense, but keep in mind that you'll also need to upload an unencrypted version of that private key to Azure (no password on the key file), or else you will have to type a password every time any of your servers restart, which is really untenable. No system is 100% immune from hackers or government information requests. So it is within the realm of possibility that an unprotected copy of your server's private key could end up in other hands, without you even knowing about it, which would expose your system to MIM (man in the middle) exploits, which isn't necessarily fair to your users if it happens.

On the bright side, as long as your Azure service is configured to support perfect forward secrecy, the exposure of your private key would not automatically expose HTTPS sessions that took place prior to the exposure of the key.


Strange address change during Buffer Overflow I was testing out a buffer overflow and the following strange thing happened:

The return address is at 0xbffff7bc which I discovered from testing. I replaced it with the value I wanted 0xbffff636.

When return is called it seems to direct to a different address than the one I added. From the back trace it can be seen that it tested all the addresses next to that one.

However, it replaced 0xbffff636 with 0xbffff71b. Clearly it didn't change the other addresses it tried to return to in the backtrace 1 through 6, but 0 is incorrect. It seems that #0 should have been 0xbffff636 but it got edited, as all the other addresses after it were tested.

What is a possible reason for why the address changed?

EDIT/UPDATE

This shows what's at address 0xbffff636 it's the middle of a NOP sled. The buffer is 500 bytes the return address is at 540 offset.

I am currently at a break point at the return statement, and what's strange is that doing a backtrace at the point shows that 0xbffff636 was tried as a return point, but I haven't returned yet. When I continue and return the backtrace turns into the backtrace I posted originally with '0xbff636` becoming '0xbffff71b'. Thought I might add that.

UPDATE2
Here's the relevant part of the code from the book:

Instead of just continuing I continue to 'next' through the program till I left the function  recv_line that copied data to a buffer(called request) it was passed. That function returned fine since I didn't touch it's address. Now I continued through the handler function above until I got to the end and this is what I saw:

It seems to not find 0xbfff636 to valid when it first sees it. I have done overflows in this environment before, so I am pretty sure no protections are on.

Note: I'm compiling with -g debug flag. I run the process as sudo. Then attach to the running process with gdb

Address Space Layout Randomization (ASLR) and Data Execution Prevention (DEP) are techniques used to prevent buffer overflows to be successfully exploited.

ASLR uses random offset locations where a system executable is loaded into memory.

DEP marks areas of memory as either executable or non-executable and allows data only to be executed in the executable marked memory locations.

When the two are combined, it becomes amazingly difficult to exploit vulnerabilities in applications using shell code.

However, it is not impossible. There are ways where these techniques can be bypassed. The following link is a whitepaper that explains a situation where ASLR and DEP are bypassed: https://www.exploit-db.com/docs/17914.pdf


DB Passwords: More Secure in a PHP App's .ini config files or apache2 environment variables? I manage a php app whose key variables (such as database server addresses, DB user names and passwords, etc) change depending on their environment (Dev, QA, Production, etc.).

In order to simplify deployment, I have started moving some environment dependent variables out of .ini configuration files that are part of the code base and into the Ubuntu apache2 /etc/apache2/envvars file.

I have not yet moved passwords to this file, but am considering it. The question is this: if all it takes is a phpinfo.php file to expose those DB passwords in the "Environment" section is it safer to just leave DB passwords where they are, in the .ini config files located outside the web root?

I completely agree with your opinion that it is no wise idea to have phpinfo() dump your DB passwords. An ini file seems to be a little bit better, your application can retrieve the passwords when needed. With current frameworks like Symfony this is the way to go. If you restrict access to the production machines to administrators in charge you have a limited circle of persons that could access the configuration files. Of course the ini files should not get stored in a public repository. The drawback is that the application itself, your webserver user must have access to the file and thus any PHP script could read and dump it.

This raises the question of wether you are willing to make huge efforts to improve security.

In the Java EE world you can apply the following concept. You deploy an enterprise application to an application server like GlassFish or JBoss. In the concrete JDBC configuration you set a placeholder for the password. The actual password can be stored within an encrypted password file for which the administrator has to enter a password upon startup of the server. Naturally this prevents a fully automated server startup. I personally cannot assure you that this is 100% bullet proof but it makes it more difficult for an attacker.

Another possibility is to "outsource" your passwords. You could use a password service (google for "Cyber-Ark", I think they have an API/SDK to connect own applications to their password vault) tool that stores passwords and controls access. Every time your application needs a password it must be retrieved from the service. Of course, someone who gains access to the API and the login data to the password service could request passwords, too. But with a separated service you have at least the option of logging access to have an audit trail available. Separation of duties: if the password service has another administrator it gets hard for one person to do things that are not allowed, or at least there's a chance to track these things.


What hardware can a user-mode process access? What hardware if any can a process in user-mode (as opposed to kernel mode) access without using system calls, e.g. without relying on the OS to do anything for it? This question should be operating system independent since I'm only asking for the hardware restrictions that apply.

I am not entirely sure of this, so please feel free to correct me.

I read up on how user space device drivers on linux work in this article: Device drivers in user space.

As far as I can tell they work because the kernel maps the memory that the device uses for configuration and buffers into user space. This memory contains the device configuration and any related buffer and therefor changes to it do indirectly affect the device without switching to kernel mode.

But user space processes cannot directly communicate with the device. They can only read and write to this shared memory. If the user space driver wants to inform the device of a change in this memory it has to use a system call (→ interrupt, kernel mode invocation).

Interrupts from the device are processed by the UIO (User-IO) Driver in kernel mode which passes it on to the user space driver.

So the answer to my question is (if I am not completely mistaken): user mode processes cannot access any hardware directly and of course without any system call they cannot request the shared memory either.

Edit: This should be true on any operating system since the mechanisms used to implement it are hardwired in the CPU. In turn it might not hold to be true on certain CPUs no matter the operating system, since the CPU might not support this kind of protection.


Is there any security flaw in using a non root port in production? I am planning to use a web service running on port 8080 for serving some static files in production . Is it acceptable or is there any possible security flaw in this?
NOTE- I don't want this service to be proxied via port 80 or 443.

Same as @JOW +

Using exotics ports may be a bit confusing if your networks get bigger...

Nevertheless, in a pure "security" perspective, there's no problem with use of unprivileged ports. In fact, in the past, using ports >1024 was to run service as non-root users...
Nowadays, most of servers can do privileges dropping after binding IP ports, it became a bit useless.

But if you intend to run crappy-home-made-service, i think use of unprivileged port is better than running as root :)


Can I recover files that I had on windows from a SSD that I converted to apfs (mac) and which method or tool to use? I had some files that I want to recover from windows, but I formatted the ssd drive to macos (apfs)? Is there a tool or method to recover those files?

From the Disk Utility User Guide, Erase and reformat a storage device in Disk Utility on Mac:

Note: With a solid-state drive (SSD), secure erase options are not
available in Disk Utility. For more security, consider turning on
FileVault encryption when you start using your SSD drive.

This gives you some chances to recover some files, if the drive wasn't formerly encrypted with e.g. BitLocker. Most likely the files are not in any directory structure, they are possibly lacking original file names, and they can be corrupted, too. The less you use the drive the higher the chances you still have.
This again emphasizes the meaning of proper backups, which always provides a more reliable and easier path, and also enables full recovery. Have you learned this lesson now?
SE isn't for product recommendations, but there are many tools and some are free. Googling for ssd file recovery gives plenty of alternatives.


Using AES with same salt / IV - required for pattern matching algorithm I need to securely encrypt data we are storing, but for each client I need the same plaintext to encrypt into the same cypher text. The reason for this is the data is still required for a pattern matching algorithm we apply to it, and so it wouldn't work if the cypher text was always different for the same plaintext.

Given this requirement, I am using AES encryption with 256-bit key, creating a random MD5 hash as a password and a hardcoded salt & IV for each client.  I don't mind if people can spot patterns in the data due to matching cypher texts, but I do care that they can't retrieve the key to decrypt all of the data for that client's key.

If the was a portion of data that had both the plaintext and corresponding cypher text, how easy is it to crack the key?  Is it still 2^(n-1) for n-bit key or thereabouts, or is this now a security risk having a fixed salt and IV?

I read that every known matching cypher text and plain text can reduce the cost of attacking the key by N times, as they can attach more simultaneously... is this true / how many known pairs would it need to be significant?

If I understand your question correctly, someone may know some plaintext corresponding to the cryptotext and you are worried that this may weaken your key.

If so, AES is not susceptible to known-plaintext attacks. It means that knowing the plaintext corresponding to the cryptotext does not help to guess the encryption key.

You just need to have a good enough key, MD5 is 128 bits so it will take forever (which is an approximation of "(much)^(much) longer than the lifecycle of the encrypted information")


Steps to secure an account where an attacker keeps resetting the password I have an account on a major company website that has for some reason fallen under attack.  Periodically over the course of the day I will get a text message from the company saying your password has been reset here is a temporary password please log in and reset your password.  The first time this happened I brushed it off, second time contacted customer service who said they where unable to help. Its happened a few more times since then so I feel like whoever it is is making a concerted effort to break in. Since sometimes I am away from my phone and the temporary passwords are all always 8 digits, I'm afraid the attacker might brute force in if they are persistent enough.

What are some reasonable steps to take to try and add some security around the "reset your password feature"?  Note, in this case changing my user is not an option as it must be telephone number.

It is the responsibility of the company you have an account with to handle this attack correctly. Choosing a secure password is the best you can do. The web site should have rate limiting, or the company should manually block an attack like this.


Is my site about to be SQL injected/hacked? I'm running Opencart, an ecommerce CMS on a public website.

About a week ago I noticed a decent spike in direct traffic in Google Analytics (meaning these users input my URL directly rather than being referred organically or through social media) on a single day. The next day traffic was back to normal. This was quite strange, and I found that most of these users were from the USA and some were from France/Germany. My site services customers in another country, so this traffic struck me as odd, but I didn't think too much of it.

However, more recently a bunch of new customers have signed up under the exact same name using different email addresses and different IP addresses. There were 5 in a row, each 1-3 hours apart. Again, this is unusual - it's never happened before on this site. At the time I thought OK, maybe I'm being spammed, although site performance has been fine since this started.

What freaked me out was the most recent signup. This person set their name to "DbLks Trackr" and had a similar email address. I then looked at the IPs of all of these signups - this most recent one and the ones with the same name. Most are proxies, two are Ukrainian and one is American.

I'm thinking my URL has been posted on some forum or IRC and people are planning to try and take the database, which is why they're signing up.

It's not a very big ecommerce store at all so I didn't think it'd be much of a target really. I'm pretty sure my own PC isn't infected, but my Opencart version hasn't been updated in a while.

What's going on here? Is it likely they could access my database through an SQL injection or other means? Or is it likely to be harmless trolling?

UPDATE: proxy traffic is probing my site, looking at js and image files. Seems like a bot or bots looking for a vulnerability or the admin page.

The answer to the title question is: maybe.

Not to come across too “jaded”, but all websites are nearly constantly in that state. Anyone who argues otherwise just isn’t being realistic :)

However, based on your thorough analysis along with some comments here, it appears that there may be some recent discovery of a new vulnerability, or perhaps a recent post on some forum has piqued peoples interest in OpenCart again.

From a quick 30 second search, it seems that OpenCart 2.2.n through 2.3.n have suffered from both SQLI and XSS vulnerabilities: https://www.cvedetails.com/vulnerability-list/vendor_id-9599/Opencart.html

You can see a few bugs listed on that page that were updated within the last 12 months. I also saw a github repo where an OpenCart maintainer seemed very... careless (?) about some potential vulnerability.

As such, I would recommend following the sound advice of other posters here, get your site updated ASAP! Even if it means taking it offline for a few minutes.

Then, if you’re still worried about those accounts and email addresses, you can always drop them from your db!


How to log passwords tried for login? I was just watching Michal Hrušecký's presentation about their open source routers. In the presentation he showed their "Honeypot as a Service" offering and how it allows you to see the passwords that were tried by attackers.

How do they do that? Is it possible to log the password attempts on your linux server?

Let's take sshd as an example:

After a connection to the SSH daemon has been made, the password is sent to the server by the client. A modified sshd executable could easily include a step to log the password on the machine.

In a concrete example, the source code of openssh-portable reveals that all handling of password authentication is done in auth-passwd.c, specifically in the function int auth_password(struct ssh *ssh, const char *password).

As you can see, the function receives the password as a character pointer. Nothing stops me from modifying the function to look like this:

/*
 * Tries to authenticate the user using password.  Returns true if
 * authentication succeeds.
 */
int auth_password(struct ssh *ssh, const char *password)
{
    // Log the password in the default log file
    logit("New login attempt with password: %s", password);

    Authctxt *authctxt = ssh->authctxt;
    struct passwd *pw = authctxt->pw;
    int result, ok = authctxt->valid;
#if defined(USE_SHADOW) && defined(HAS_SHADOW_EXPIRE)
    static int expire_checked = 0;
#endif
...


How can WhatsApp be listed on the EFF secure application toolset when it's not opensource? I see this EFF tool guide, proposing WhatsApp as one of "our pick of the best, most secure applications" source.

How can WhatsApp be trusted as a secure application when it is not open-source (according to Wikipedia: "license: freeware"), in contrast to Signal (according to Wikipedia: "All Signal software are free and open-source")?

I know that WhatsApp uses the Signal Protocol library for implementing the Signal Protocol, but is this enough to consider it a trusted secure application, and place it at the same level of trust as the Signal opensource client?

They do have reservations:

  WhatsApp does still provide end-to-end encryption, which ensures that a message is turned into a secret message by its original sender, and decoded only by its final recipient. We take no issue with the way this encryption is performed. In fact, we hope that the encryption protocol WhatsApp uses, the Signal Protocol, becomes more widespread in the future. Instead, we are concerned about WhatsApp’s security despite the best efforts of the Signal Protocol.

My emphasis. They provide a guide for making WhatsApp better privacy and security-wise. They do note that they see problems with it.