Encrypt passwords as securely as possible

Question

I wonder how to encrypt passwords on Android and what are the best practices.

I am using Eclipse, Sqlite database to store the password locally and Mysql with PHP to store on the server via HttpClient. My application will be for online and offline use. Therefore any registration or alteration of user data, is done on the server and only then locally, that is, only online that the user can register or change his data.

An alternative I think would be to encrypt the password, generate a hash to prevent it from being changed while sending to the server and generate a sort of device signature hash so the server knows that the password came from a device with the application installed and concatenate everything would look like this:

"Encrypted Password" + "Integrity Hash" + "Authenticity Hash"

And the server would check all this and store in the database all this together also locally and externally.

Answer 1

An alternative I think would be to encrypt the password, generate a hash to prevent it from being changed while sending to the server and generate a sort of device signature hash so the server knows that the password came from a device with the application installed and concatenate everything would look like this:

Never invent your own encryption! The chances of something going wrong are huge. Instead, use a well-established protocol for what you want:

1. Connect to your server using SSL/TLS. So the data you send to it will already be confidential and intact, it is not necessary to encrypt the password or generate a hash (incidentally, a hash does not prevent it from being changed during sending; a MAC maybe, but this is another story). And if you combine this with a customer authentication using certificates, you already guarantee the authenticity too, just send only the same simple password and ready!

2. If you need to store the user password on the device (it is not clear in the question if the user will have to type it every time you connect to your server, or if it will be saved on the device), look for some feature of the system itself to help you. I have no experience with Android, but a quick search brought me the AccountManager - which seems to me to be a centralized means of managing the accounts that the user has in various services. I suggest to study it.

Detailing

If what I explained above was not clear, let me break the problem down into smaller pieces to make it easier to understand the proposed solution (and maybe present some alternatives):

Saving passwords on the device

Unless you want the user to enter their password every time they connect to your server, you need some method of authentication to be stored on the device. In this case, you cannot hash the password because you need the password in its original format to send to the server (otherwise hash becomes the password, and any attacker who gets a copy of the hash already has the credentials necessary to authenticate with the server). Encryption is an idea, but where to keep the key? This is a complicated situation, hence my suggestion to use what you already have ready on Android and get it out of your head...

Communicating safely with the server

If you do not use SSL/TLS (e.g., HTTPS), you cannot guarantee that communication with the server will not be intercepted and even modified (particularly on open networks). Trying to "turn around" without TLS will leave you with an unsafe solution and/or force you to reinvent many wheels. So I strongly suggest using this protocol.

When creating a secure channel via TLS, you can send the user credentials in flat format without the need to encrypt. Because the protocol guarantees the confidentiality (i.e. no one can read the communication) and the integrity (no one can change the communication) of both, in addition to the authenticity of the server (the client knows he is communicating with the right server).

Authenticating the device

In the question you show concern about the device that originated the request ("...so the server knows that the password came from a device with the application installed..."). That is, in addition to authenticating the user with the server, you also want to authenticate the device with the server.

At first, this can also be done via SSL/TLS, using customer certificates. Roughly, when installing the application it would generate a certificate for that device, register that certificate on the server (or simply have that certificate signed by an CA that the server trusts)and then when communicating via TLS would use that certificate with the protocol. So both client and server would be authenticated to each other, and it would be enough then you authenticate the user (sending the password in its normal format).

If all this is too complicated, a simpler alternative would be to generate a random password to be the "device password", and register it on the server next to the user’s password. This password would then be sent during authentication, also under the previously established secure channel.

Saving passwords on the server

On the server, of course, you will not store the password(s) in flat format, but a hash(s) of the same(s). See the question "How to hash passwords securely?" for more details.

Answer 2

After some research I found a ready example using AES on this site: http://www.iai.art.br/radar/android-development-criptografia-baseada-em-senha/

It worked well it encryption and decryption too, for me I just wanted one that only encrypted without possibility of decryption, but this one fits for now. My doubt in this code is in relation to this method of encryption that I do not know if it will generate some code encrypted with this character "#", because I am using it and this " " to separate the string and mount the fields to store in the bank. The method is this:

public static String encrypt(String plainText, String password)    throws
  NoSuchAlgorithmException,
  InvalidKeySpecException,
  NoSuchPaddingException,
  InvalidParameterSpecException,
  IllegalBlockSizeException,
  BadPaddingException,
  UnsupportedEncodingException,
  InvalidKeyException,
  InvalidAlgorithmParameterException
{
  byte[] saltBytes = salt.getBytes("UTF-8");
  byte[] ivBytes = initializationVector.getBytes("UTF-8");
  SecretKeyFactory factory =   SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");

  PBEKeySpec spec = new PBEKeySpec(
       password.toCharArray(),
       saltBytes,
       pswdIterations,
       keySize
  );
  SecretKey secretKey = factory.generateSecret(spec);
  SecretKeySpec secret = new SecretKeySpec(secretKey.getEncoded(), "AES");
  Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
  cipher.init(Cipher.ENCRYPT_MODE, secret, new       IvParameterSpec(ivBytes));
  byte[] encryptedTextBytes =  cipher.doFinal(plainText.getBytes("UTF-8"));
  return Base64.encodeToString(encryptedTextBytes, 0);
}

And if anyone has a better suggestion, it would be very helpful.