Hi all,
so here i’m a bit confused. After talking to moxie in this issue #7553 at github. I can’t understand the basic encryption at rest signal provides. As mentioned in this issue, i and some other always asumed that the password you choose for signal interacts with the local encryption. This is not the case:
The Signal screen lock is just that, a screen lock. It is not connected to any kind of data encryption, it is just a screen that someone holding your phone has to unlock to get past.
The data on disk is encrypted using a key that’s stored in the Android system keystore, which is hardware backed on some devices (presumably most new devices). However, the sad truth is that if what you’re really worried about is protecting your messages from someone with forensic physical access to your device, your best bet is to run Signal on an iPhone instead.
This would prevent forensics if i’m not mistaken. If the pass is good enough.
Probably not. It’s in memory in many places, since there’s no way to control that with the JVM. Also, password based encryption is not generally effective, particularly given the mobile form factor.
What does than this mean moxie: https://github.com/signalapp/Signal-Android/wiki/Using-Signal
Every official support page says otherwise, the feature itself is called a “screen lock,” etc. All of these wiki pages are made by people here like yourself, I’ll delete this one.
I beg for an option that we can encrypt the data at rest with our own chosen pass. This is fundamental.
Not only would that be ineffective, it’s not really possible. A message arrives, but the database is “locked.” What do we do? We could put it somewhere temporarily and notify the user, but what if the message is from someone who is blocked? There’s no way to know that, because that information is… in the database. etc etc.
I did search around a bit how threema handles the local encryption. And did come up with this here from their security white paper.
Android
On Android, Threema stores local data in an SQLite database within the app’s private data directory. Android
ensures that no other apps can access this data directory (as long as the device is not rooted). The database
itself is protected by SQLCipher with AES-256, and any media files (which are stored separately in the app’s
private directory within the file system) are also encrypted using AES. The key is randomly generated when the
database is first created, and can be protected with a user-supplied passphrase (which is of course necessary
if the user wishes to take advantage of this encryption). The passphrase is never written to permanent storage
and therefore needs to be entered whenever the app process restarts (e.g. after a low-memory situation, or after
the device has rebooted). Alternatively, the user may enable full-device encryption if supported by the device
and Android version
The Brown University posted this here:
The Signal Storage Architecture
When Signal is installed it first generates keying material. This includes a password P
, a 128-bit AES key K, an HMAC-SHA1 key G and an elliptic curve Diffie-Hellman public/private key pair (pk=gx,sk=x). The tuple (K,G,sk), which we refer to as the master secrets, is then encrypted with P using password-based encryption and stored on disk while pk is stored in plaintext. Note that these master secrets are only used to encrypt messages when stored and not in-transit. The password P
is either user-generated (if the password option is enabled) or fixed to the string “unencrypted” (if the password option is disabled).
Signal operates in two modes: open mode, which is when the password P is cached; and closed mode, when P is not cached.
Can somebody please explain why i think this does not fit with what moxie said???
How can we improve local encryption and make it forensic resistant???