Vote for should we change the setting 'allow-external-apps'

[zongou]

The current situation is, it does not keep our content safe, not at all. If malicious program want to change it, there is no barrier at all.
but it actually cause a trouble for user as a common need.

[agnostic-apollo]

Where do you propose the graphical setting will be stored?

[agnostic-apollo]

I meant where would you store the value of the setting so that it can be loaded when the app starts?

[zongou]

I meant where would you store the value of the setting so that it can be loaded when the app starts?

I have asked AI, that is the reply
When developing an Android wallet app, it's crucial to protect sensitive information like strings that may contain private keys, passwords, or any other secure data. Here's a comprehensive approach to keeping those strings safe:

1. Use Encrypted Storage:

a. Android EncryptedSharedPreferences:

For storing small strings securely, consider using the EncryptedSharedPreferences class, which provides a simple API for storing sensitive data.

import androidx.security.crypto.EncryptedSharedPreferences;
import androidx.security.crypto.MasterKey;

// Initialize EncryptedSharedPreferences
MasterKey masterKey = new MasterKey.Builder(context)
                .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
                .build();

SharedPreferences sharedPreferences = EncryptedSharedPreferences.create(
                context,
                "secret_shared_prefs",
                masterKey,
                EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
                EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM);

// Save the data
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putString("your_key", "your_sensitive_string");
editor.apply();

// Retrieve the data
String secureString = sharedPreferences.getString("your_key", null);

b. Android Keystore System:

For even higher security, especially for cryptographic keys or other sensitive information, use the Android Keystore System.

import android.security.keystore.KeyGenParameterSpec;
import android.security.keystore.KeyProperties;

KeyGenerator keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore");
keyGenerator.init(new KeyGenParameterSpec.Builder("your_key_alias",
        KeyGenParameterSpec.PURPOSE_ENCRYPT | KeyGenParameterSpec.PURPOSE_DECRYPT)
        .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
        .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
        .setKeySize(256)
        .build());
SecretKey secretKey = keyGenerator.generateKey();

2. Use Strong Encryption:

If you need to encrypt sensitive strings before storage or transmission, use a strong encryption algorithm. AES (Advanced Encryption Standard) is commonly used.

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

public String encrypt(String data, byte[] key) throws Exception {
    SecretKeySpec secretKey = new SecretKeySpec(key, "AES");
    Cipher cipher = Cipher.getInstance("AES");
    cipher.init(Cipher.ENCRYPT_MODE, secretKey);
    byte[] encrypted = cipher.doFinal(data.getBytes());
    return Base64.encodeToString(encrypted, Base64.DEFAULT);
}

public String decrypt(String encryptedData, byte[] key) throws Exception {
    SecretKeySpec secretKey = new SecretKeySpec(key, "AES");
    Cipher cipher = Cipher.getInstance("AES");
    cipher.init(Cipher.DECRYPT_MODE, secretKey);
When developing an Android wallet app, securing sensitive data such as strings (like private keys, user credentials, or payment information) is crucial. Here are some best practices to safely store such data:

### 1. **Use Encrypted Shared Preferences**
Android provides a way to securely store key-value pairs using **EncryptedSharedPreferences**. This offers encryption at rest and is simple to use.

```kotlin
val sharedPreferences = EncryptedSharedPreferences.create(
    "secret_shared_prefs",
    MasterKey.Builder(context).setKeyScheme(MasterKey.KeyScheme.AES256_GCM).build(),
        context,
    EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
    EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
)
sharedPreferences.edit().putString("key", "value").apply()

For sensitive information like cryptographic keys, use the Android Keystore System. Store cryptographic keys securely and use them to encrypt/decrypt sensitive information in your app.

                        ```kotlin

val keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore")
keyGenerator.init(
KeyGenParameterSpec.Builder(ALIAS,
KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)
.setBlockModes(KeyProperties.BLOCK_MODE_GCM)
.setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
.build()
)
val secretKey = keyGenerator.generateKey()

### 3. **Use Secure Storage Libraries**
Consider using third-party libraries that handle security for you. Some popular ones include:

- **SecurePreferences (by Mobsya)**
- **SQLCipher** (for SQLite databases)
If you prefer more control, you can manually encrypt the strings before storing them. Use a secure encryption algorithm like AES along with a secure key management practice.

```kotlin
fun encrypt(data: String, key: SecretKey): ByteArray {
    val cipher = Cipher.getInstance("AES/GCM/NoPadding")
    cipher.init(Cipher.ENCRYPT_MODE, key)
    return cipher.doFinal(data.toByteArray())
}

If feasible, consider offloading sensitive information storage to a secure backend server where data can be stored and accessed securely.
Never hardcode sensitive strings or API keys directly into your source code. Use build configurations or environment variables instead for development.
Make your users aware of the importance of keeping their credentials safe. Encourage the use of strong passwords and two-factor authentication (2FA) if relevant.

Stay updated with the latest security practices and vulnerabilities (e.g., OWASP Mobile Top Ten) and regularly review your app's security measures.

Perform security audits regularly and consider using automated security testing tools to analyze your app for vulnerabilities.

Summary

Ultimately, the key to safe string storage in your Android wallet app lies in using secure storage mechanisms, encrypting sensitive information, and following best practices in security and user awareness. By combining these methods, you can enhance the security of your app and protect user data effectively.

[agnostic-apollo]

Yes, keystore can be used to store private settings, but what you are not realizing is that those malicious programs have the same access as main Termux app. They could extract/write data to keystore if they wanted, will need a context though, but can likely use termux-api APIs.

Secondly, what's the point of preventing a Termux owned process to modify the setting. The malicious program already has full access to the app data anyways to do whatever it wants, why would it bother with giving another app access. Enabling the setting would just mean some other app can access the data as well, which also would have to be installed by the user. And the malicious program could just communicate with the second app with a server socket instead of Termux APIs.

Thirdly, allow-external-apps is a secondary safety check. The primary one is RUN_COMMAND permission which other apps already need to be granted through Android "UI" by the user.

[zongou]

I agree that this setting cannot guaranty our data safety in any way. since malicious program has access to data already. even if we keep this setting in a place where they cannot touch, they do not need it. they already own our data.

[zongou]

Will this restriction be removed in the future? it seems meaningless, only to make user's life harder