Was ist der beste Weg zum speichern der Benutzer-Einstellungen in der Android-Anwendung

Ich Stimme mit Reto und fiXedd. Objektiv betrachtet ist es nicht sehr sinnvoll, investieren viel Zeit und Aufwand in die Verschlüsselung der Passwörter in SharedPreferences, da jeder Angreifer, der Zugriff auf die preferences-Datei ist ziemlich wahrscheinlich auch Zugriff auf Ihre Anwendung binäre, und daher der Schlüssel zum entschlüsseln das Passwort.

Jedoch, dass gesagt wird, es scheint ein publicity-initiative geht auf die Ermittlung von mobile-Anwendungen, speichern Ihre Passwörter im Klartext in SharedPreferences und glänzend ungünstigen Licht auf diese Anwendungen. Sehen http://blogs.wsj.com/digits/2011/06/08/some-top-apps-put-data-at-risk/ und http://viaforensics.com/appwatchdog für einige Beispiele.

Während wir brauchen mehr Aufmerksamkeit für die Sicherheit im Allgemeinen würde ich behaupten, dass diese Art von Aufmerksamkeit auf diese eine bestimmte Frage nicht wirklich erheblich erhöhen unsere Sicherheit insgesamt. Doch Wahrnehmungen sein, wie Sie sind, hier ist eine Lösung zum verschlüsseln der Daten in SharedPreferences.

Einfach wickeln Sie Ihre eigenen SharedPreferences-Objekt in diese ein, und alle Daten, die Sie Lesen/schreiben, werden automatisch verschlüsselt und entschlüsselt werden. zB.

final SharedPreferences prefs = new ObscuredSharedPreferences( 
    this, this.getSharedPreferences(MY_PREFS_FILE_NAME, Context.MODE_PRIVATE) );

//eg.    
prefs.edit().putString("foo","bar").commit();
prefs.getString("foo", null);

Hier ist der code für die Klasse:

/**
 * Warning, this gives a false sense of security.  If an attacker has enough access to
 * acquire your password store, then he almost certainly has enough access to acquire your
 * source binary and figure out your encryption key.  However, it will prevent casual
 * investigators from acquiring passwords, and thereby may prevent undesired negative
 * publicity.
 */
public class ObscuredSharedPreferences implements SharedPreferences {
    protected static final String UTF8 = "utf-8";
    private static final char[] SEKRIT = ... ; //INSERT A RANDOM PASSWORD HERE.
                                               //Don't use anything you wouldn't want to
                                               //get out there if someone decompiled
                                               //your app.


    protected SharedPreferences delegate;
    protected Context context;

    public ObscuredSharedPreferences(Context context, SharedPreferences delegate) {
        this.delegate = delegate;
        this.context = context;
    }

    public class Editor implements SharedPreferences.Editor {
        protected SharedPreferences.Editor delegate;

        public Editor() {
            this.delegate = ObscuredSharedPreferences.this.delegate.edit();                    
        }

        @Override
        public Editor putBoolean(String key, boolean value) {
            delegate.putString(key, encrypt(Boolean.toString(value)));
            return this;
        }

        @Override
        public Editor putFloat(String key, float value) {
            delegate.putString(key, encrypt(Float.toString(value)));
            return this;
        }

        @Override
        public Editor putInt(String key, int value) {
            delegate.putString(key, encrypt(Integer.toString(value)));
            return this;
        }

        @Override
        public Editor putLong(String key, long value) {
            delegate.putString(key, encrypt(Long.toString(value)));
            return this;
        }

        @Override
        public Editor putString(String key, String value) {
            delegate.putString(key, encrypt(value));
            return this;
        }

        @Override
        public void apply() {
            delegate.apply();
        }

        @Override
        public Editor clear() {
            delegate.clear();
            return this;
        }

        @Override
        public boolean commit() {
            return delegate.commit();
        }

        @Override
        public Editor remove(String s) {
            delegate.remove(s);
            return this;
        }
    }

    public Editor edit() {
        return new Editor();
    }


    @Override
    public Map<String, ?> getAll() {
        throw new UnsupportedOperationException(); //left as an exercise to the reader
    }

    @Override
    public boolean getBoolean(String key, boolean defValue) {
        final String v = delegate.getString(key, null);
        return v!=null ? Boolean.parseBoolean(decrypt(v)) : defValue;
    }

    @Override
    public float getFloat(String key, float defValue) {
        final String v = delegate.getString(key, null);
        return v!=null ? Float.parseFloat(decrypt(v)) : defValue;
    }

    @Override
    public int getInt(String key, int defValue) {
        final String v = delegate.getString(key, null);
        return v!=null ? Integer.parseInt(decrypt(v)) : defValue;
    }

    @Override
    public long getLong(String key, long defValue) {
        final String v = delegate.getString(key, null);
        return v!=null ? Long.parseLong(decrypt(v)) : defValue;
    }

    @Override
    public String getString(String key, String defValue) {
        final String v = delegate.getString(key, null);
        return v != null ? decrypt(v) : defValue;
    }

    @Override
    public boolean contains(String s) {
        return delegate.contains(s);
    }

    @Override
    public void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener onSharedPreferenceChangeListener) {
        delegate.registerOnSharedPreferenceChangeListener(onSharedPreferenceChangeListener);
    }

    @Override
    public void unregisterOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener onSharedPreferenceChangeListener) {
        delegate.unregisterOnSharedPreferenceChangeListener(onSharedPreferenceChangeListener);
    }




    protected String encrypt( String value ) {

        try {
            final byte[] bytes = value!=null ? value.getBytes(UTF8) : new byte[0];
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
            SecretKey key = keyFactory.generateSecret(new PBEKeySpec(SEKRIT));
            Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
            pbeCipher.init(Cipher.ENCRYPT_MODE, key, new PBEParameterSpec(Settings.Secure.getString(context.getContentResolver(),Settings.Secure.ANDROID_ID).getBytes(UTF8), 20));
            return new String(Base64.encode(pbeCipher.doFinal(bytes), Base64.NO_WRAP),UTF8);

        } catch( Exception e ) {
            throw new RuntimeException(e);
        }

    }

    protected String decrypt(String value){
        try {
            final byte[] bytes = value!=null ? Base64.decode(value,Base64.DEFAULT) : new byte[0];
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
            SecretKey key = keyFactory.generateSecret(new PBEKeySpec(SEKRIT));
            Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
            pbeCipher.init(Cipher.DECRYPT_MODE, key, new PBEParameterSpec(Settings.Secure.getString(context.getContentResolver(),Settings.Secure.ANDROID_ID).getBytes(UTF8), 20));
            return new String(pbeCipher.doFinal(bytes),UTF8);

        } catch( Exception e) {
            throw new RuntimeException(e);
        }
    }

}

InformationsquelleAutor emmby

Mithilfe des snippet zur Verfügung gestellt von Richard, können Sie das Kennwort verschlüsseln, bevor Sie Sie speichern. Die preferences-API jedoch nicht bieten eine einfache Möglichkeit zum abfangen der Wert und verschlüsseln Sie es - Sie werden es blockieren kann gespeichert werden über eine OnPreferenceChange Zuhörer, und Sie theoretisch ändern könnte, es durch eine preferenceChangeListener, aber, dass die Ergebnisse in einer endlos-Schleife.

Ich hatte zuvor vorgeschlagen, das hinzufügen einer "versteckten" Einstellung, um dies zu erreichen. Es ist definitiv nicht der beste Weg. Ich werde an zwei anderen Optionen halte ich für mehr lebensfähig.

Erste, das einfachste ist, in einer preferenceChangeListener, können Sie sich den eingegebenen Wert, verschlüsseln Sie es, und speichern Sie ihn dann auf eine alternative Datei Einstellungen:

  public boolean onPreferenceChange(Preference preference, Object newValue) {
      //get our "secure" shared preferences file.
      SharedPreferences secure = context.getSharedPreferences(
         "SECURE",
         Context.MODE_PRIVATE
      );
      String encryptedText = null;
      //encrypt and set the preference.
      try {
         encryptedText = SimpleCrypto.encrypt(Preferences.SEED,(String)newValue);

         Editor editor = secure.getEditor();
         editor.putString("encryptedPassword",encryptedText);
         editor.commit();
      }
      catch (Exception e) {
         e.printStackTrace();
      }
      //always return false.
      return false; 
   }

Die zweite Möglichkeit, und die Art und Weise, die ich jetzt bevorzugen, erstellen Sie Ihre eigenen benutzerdefinierten Vorlieben, die Ausweitung EditTextPreference, @Override ' Ing der setText() und getText() Methoden, so dass setText() verschlüsselt das Kennwort, und getText() null zurück.

InformationsquelleAutor Mark

Okay; es ist schon eine Weile her, seit die Antwort ist eine Art von gemischten, aber hier ein paar Allgemeine Antworten. Ich recherchierte wie verrückt und es war schwer zu bauen eine gute Antwort

1. Den MODE_PRIVATE Methode gilt als generell sicher, wenn Sie davon ausgehen, dass der Benutzer nicht root das Gerät. Ihre Daten werden im Klartext gespeichert in einem Teil des Dateisystems, der kann nur zugegriffen werden, das ursprüngliche Programm. Das Zeug packte das Passwort mit einer anderen app auf einem gerooteten Gerät einfach. Dann wieder, wollen Sie Unterstützung gerootete Geräte?

2. AES ist immer noch die beste Verschlüsselung, die Sie tun können. Achten Sie dies, wenn Sie beginnen eine neue Umsetzung, wenn es schon eine Weile her, seit ich dies geschrieben. Das größte Problem mit diesem ist, "Was zu tun ist mit dem Schlüssel?"

So, jetzt sind wir bei dem "Was zu tun ist mit dem Schlüssel?" Teil. Dies ist der schwierige Teil. Immer der Schlüssel stellt sich heraus, dass Sie nicht schlecht. Sie können eine key derivation function, um einige Passwort und machen es zu einem ziemlich sicheren Schlüssel. Sie erhalten in Fragen wie "wie viele Pässe hast du mit PKFDF2?", aber das ist ein anderes Thema

1. Idealerweise speichern Sie die AES-Schlüssel aus dem Gerät. Sie haben, um herauszufinden, eine gute Möglichkeit zum abrufen des Schlüssels vom server sicher, zuverlässig, und sicher obwohl

2. Haben Sie eine login-Sequenz von einer Art (selbst die original-login-Sequenz, die Sie tun, für remote-Zugriff). Sie können zwei Läufe von Ihrem key generator auf dem gleichen Passwort. Wie dies funktioniert, ist, dass Sie daraus den Schlüssel zweimal mit einem neuen Salz-und ein neues, Sicheres Initialisierungsvektor. Speichern Sie eines dieser generierten Passwörter auf dem Gerät, und verwenden Sie das zweite Kennwort als AES-Schlüssel.

Wenn Sie sich anmelden, Sie re-ableiten der Schlüssel auf dem lokalen login und vergleichen Sie es mit dem gespeicherten Schlüssel. Sobald dies geschehen ist, verwenden Sie leiten key #2 für AES.

1. Mit "im Allgemeinen sicher" - Ansatz, die Sie verschlüsseln die Daten mit AES und speichern Sie den Schlüssel in MODE_PRIVATE. Dies wird empfohlen, eine aktuelle-ish Android blog-post. Nicht unglaublich sicher, aber besser so für einige Menschen, die über nur-text -

Können Sie eine Menge von Variationen dieser. Zum Beispiel, statt einer vollständigen login-Sequenz, die Sie tun können, eine schnelle PIN (abgeleitet). Der quick-PIN ist möglicherweise nicht so sicher wie eine vollständige login-Sequenz, aber es ist viele Male sicherer als plain text

InformationsquelleAutor Joe Plante

Können Sie auch überprüfen Sie heraus dieses kleine lib, mit der Funktionalität, die Sie erwähnen.

https://github.com/kovmarci86/android-secure-preferences

Es ist ähnlich wie einige der anderen aproaches hier. Hoffe das hilft 🙂

InformationsquelleAutor Marcell

Diese Antwort basiert auf einem vorgeschlagenen Ansatz von Mark. Eine benutzerdefinierte version des EditTextPreference Klasse erstellt wird, wandelt hin und her zwischen der plain-text gesehen, in der Ansicht und eine verschlüsselte version des Passwortes gespeichert, in den Einstellungen-Speicher.

Wie hingewiesen wurde von den meisten, die geantwortet hast auf diesen thread, ist dies nicht eine sehr sichere Technik, obwohl der Grad der Sicherheit hängt zum Teil von der Verschlüsselungs - /Entschlüsselungs-code verwendet. Es ist aber ziemlich einfach und bequem, und vereiteln die meisten casual-snooping.

Hier ist der code für die benutzerdefinierte EditTextPreference Klasse:

package com.Merlinia.OutBack_Client;

import android.content.Context;
import android.preference.EditTextPreference;
import android.util.AttributeSet;
import android.util.Base64;

import com.Merlinia.MEncryption_Main.MEncryptionUserPassword;


/**
 * This class extends the EditTextPreference view, providing encryption and decryption services for
 * OutBack user passwords. The passwords in the preferences store are first encrypted using the
 * MEncryption classes and then converted to string using Base64 since the preferences store can not
 * store byte arrays.
 *
 * This is largely copied from this article, except for the encryption/decryption parts:
 * https://groups.google.com/forum/#!topic/android-developers/pMYNEVXMa6M
 */
public class EditPasswordPreference  extends EditTextPreference {

    //Constructor - needed despite what compiler says, otherwise app crashes
    public EditPasswordPreference(Context context) {
        super(context);
    }


    //Constructor - needed despite what compiler says, otherwise app crashes
    public EditPasswordPreference(Context context, AttributeSet attributeSet) {
        super(context, attributeSet);
    }


    //Constructor - needed despite what compiler says, otherwise app crashes
    public EditPasswordPreference(Context context, AttributeSet attributeSet, int defaultStyle) {
        super(context, attributeSet, defaultStyle);
    }


    /**
     * Override the method that gets a preference from the preferences storage, for display by the
     * EditText view. This gets the base64 password, converts it to a byte array, and then decrypts
     * it so it can be displayed in plain text.
     * @return  OutBack user password in plain text
     */
    @Override
    public String getText() {
        String decryptedPassword;

        try {
            decryptedPassword = MEncryptionUserPassword.aesDecrypt(
                     Base64.decode(getSharedPreferences().getString(getKey(), ""), Base64.DEFAULT));
        } catch (Exception e) {
            e.printStackTrace();
            decryptedPassword = "";
        }

        return decryptedPassword;
    }


    /**
     * Override the method that gets a text string from the EditText view and stores the value in
     * the preferences storage. This encrypts the password into a byte array and then encodes that
     * in base64 format.
     * @param passwordText  OutBack user password in plain text
     */
    @Override
    public void setText(String passwordText) {
        byte[] encryptedPassword;

        try {
            encryptedPassword = MEncryptionUserPassword.aesEncrypt(passwordText);
        } catch (Exception e) {
            e.printStackTrace();
            encryptedPassword = new byte[0];
        }

        getSharedPreferences().edit().putString(getKey(),
                                          Base64.encodeToString(encryptedPassword, Base64.DEFAULT))
                .commit();
    }


    @Override
    protected void onSetInitialValue(boolean restoreValue, Object defaultValue) {
        if (restoreValue)
            getEditText().setText(getText());
        else
            super.onSetInitialValue(restoreValue, defaultValue);
    }
}

Dieser zeigt, wie es verwendet werden kann - dies ist der "items" Datei-Laufwerke, die die Einstellungen anzeigen. Hinweis: es enthält drei ordentlichen EditTextPreference Ansichten und eine der benutzerdefinierten EditPasswordPreference Ansichten.

<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">

    <EditTextPreference
        android:key="@string/useraccountname_key"
        android:title="@string/useraccountname_title"
        android:summary="@string/useraccountname_summary"
        android:defaultValue="@string/useraccountname_default"
        />

    <com.Merlinia.OutBack_Client.EditPasswordPreference
        android:key="@string/useraccountpassword_key"
        android:title="@string/useraccountpassword_title"
        android:summary="@string/useraccountpassword_summary"
        android:defaultValue="@string/useraccountpassword_default"
        />

    <EditTextPreference
        android:key="@string/outbackserverip_key"
        android:title="@string/outbackserverip_title"
        android:summary="@string/outbackserverip_summary"
        android:defaultValue="@string/outbackserverip_default"
        />

    <EditTextPreference
        android:key="@string/outbackserverport_key"
        android:title="@string/outbackserverport_title"
        android:summary="@string/outbackserverport_summary"
        android:defaultValue="@string/outbackserverport_default"
        />

</PreferenceScreen>

Als für die eigentliche Verschlüsselung/Entschlüsselung, bleibt als übung für den Leser. Ich bin derzeit mit einigen code basiert auf diesem Artikel http://zenu.wordpress.com/2011/09/21/aes-128bit-cross-platform-java-and-c-encryption-compatibility/, obwohl Sie mit verschiedenen Werten für den Schlüssel und den Initialisierungsvektor.

InformationsquelleAutor RenniePet

Ich benutze den Android KeyStore um das Kennwort zu verschlüsseln mit RSA im ECB-Modus und speichern Sie es dann in die SharedPreferences.

Wenn ich will das Passwort wieder lese ich das verschlüsselt aus den SharedPreferences und entschlüsselt Sie mit dem KeyStore.

Mit dieser Methode generieren Sie ein public/private Key-paar, wo in der Privatwirtschaft sicher gespeichert und verwaltet Android.

Hier ist ein link, wie dies zu tun: Android KeyStore-Tutorial

InformationsquelleAutor Braveblacklion

shared preferences ist der einfachste Weg, um die Speicherung von Anwendungsdaten. aber es ist möglich, dass jeder klar unsere gemeinsame Einstellungen, Daten durch Programm-manager.also ich glaube nicht, dass es völlig sicher für unsere Anwendung.

InformationsquelleAutor Rohit Jain