admin/mkdocs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3e0aee9c300d6404f90f2676ae6f8141b6b550b4
mkdocs/docs/GoogleAndroid开发文档体系/最佳实践/安全最佳实践.md

864 lines
22 KiB
Markdown
Raw Normal View History

鏇存柊鏂囨。
2026-01-15 15:34:23 +08:00
# 安全最佳实践
鏇存柊鏂囨。
2026-01-15 16:42:52 +08:00
Android应用安全是开发过程中必须重视的方面。本文档提供Android应用安全开发的最佳实践指南。
鏇存柊鏂囨。
2026-01-15 15:34:23 +08:00
鏇存柊鏂囨。
2026-01-15 16:42:52 +08:00
## 目录
- [安全开发原则](#安全开发原则)
- [数据安全](#数据安全)
- [网络安全](#网络安全)
- [代码安全](#代码安全)
- [安全测试](#安全测试)
---
## 安全开发原则
### 1. 最小权限原则
只申请和使用应用真正需要的权限，避免过度申请权限。
#### 权限申请原则
```java
// ❌ 错误：申请不必要的权限
<uses-permission android:name="android.permission.READ_CONTACTS" />
<uses-permission android:name="android.permission.READ_SMS" />
// 如果应用不需要这些功能，不应该申请
// ✅ 正确：只申请必要的权限
<uses-permission android:name="android.permission.CAMERA" />
// 只在需要相机功能时申请
```
#### 运行时权限检查
```java
// 使用权限前检查
if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
!= PackageManager.PERMISSION_GRANTED) {
// 解释为什么需要权限
if (ActivityCompat.shouldShowRequestPermissionRationale(this,
Manifest.permission.CAMERA)) {
// 显示解释对话框
showPermissionRationale();
} else {
// 直接申请权限
ActivityCompat.requestPermissions(this,
new String[]{Manifest.permission.CAMERA},
REQUEST_CODE_CAMERA);
}
} else {
// 权限已授予，使用功能
useCamera();
}
```
### 2. 纵深防御
采用多层安全防护机制，不依赖单一安全措施。
#### 多层防护示例
```java
// 第一层：权限检查
if (checkPermission()) {
// 第二层：输入验证
if (validateInput(data)) {
// 第三层：数据加密
String encrypted = encrypt(data);
// 第四层：安全存储
saveSecurely(encrypted);
}
}
```
### 3. 安全设计
从设计阶段就考虑安全问题，而不是事后补救。
#### 安全设计要点
- **威胁建模**：识别潜在的安全威胁
- **安全架构**：设计安全的应用架构
- **安全编码**：遵循安全编码规范
- **安全测试**：进行安全测试和审计
### 4. 数据最小化
只收集和存储必要的数据，及时删除不需要的数据。
```java
// ❌ 错误：收集过多数据
class User {
String name;
String email;
String phone;
String address;
String idCard; // 不需要身份证号
String bankCard; // 不需要银行卡号
}
// ✅ 正确：只收集必要数据
class User {
String name;
String email;
// 只在需要时收集其他信息
}
```
### 5. 默认安全
默认采用安全配置，而不是默认开放。
```xml
<!-- ❌ 错误：默认导出组件 -->
<activity
android:name=".SensitiveActivity"
android:exported="true" />
<!-- ✅ 正确：默认不导出，需要时显式设置 -->
<activity
android:name=".SensitiveActivity"
android:exported="false" />
```
---
## 数据安全
### 1. 敏感数据加密
对敏感数据进行加密存储，包括密码、密钥、个人信息等。
#### 使用Android密钥库
```java
// 使用Android密钥库存储密钥
public class KeyStoreHelper {
private static final String KEYSTORE_ALIAS = "my_key";
private static final String ANDROID_KEYSTORE = "AndroidKeyStore";
public static void generateKey() throws Exception {
KeyGenerator keyGenerator = KeyGenerator.getInstance(
KeyProperties.KEY_ALGORITHM_AES, ANDROID_KEYSTORE);
KeyGenParameterSpec spec = new KeyGenParameterSpec.Builder(
KEYSTORE_ALIAS,
KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
.setBlockModes(KeyProperties.BLOCK_MODE_GCM)
.setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
.build();
keyGenerator.init(spec);
keyGenerator.generateKey();
}
public static byte[] encrypt(String data) throws Exception {
KeyStore keyStore = KeyStore.getInstance(ANDROID_KEYSTORE);
keyStore.load(null);
KeyStore.SecretKeyEntry secretKeyEntry =
(KeyStore.SecretKeyEntry) keyStore.getEntry(KEYSTORE_ALIAS, null);
SecretKey secretKey = secretKeyEntry.getSecretKey();
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] iv = cipher.getIV();
byte[] encrypted = cipher.doFinal(data.getBytes());
// 将IV和加密数据组合
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
outputStream.write(iv);
outputStream.write(encrypted);
return outputStream.toByteArray();
}
}
```
#### 数据加密存储
```java
// 加密敏感数据
public class SecureStorage {
public static void saveEncryptedData(String key, String value) {
try {
byte[] encrypted = KeyStoreHelper.encrypt(value);
// 存储加密后的数据
SharedPreferences prefs = getSharedPreferences("secure_prefs", MODE_PRIVATE);
String base64 = Base64.encodeToString(encrypted, Base64.DEFAULT);
prefs.edit().putString(key, base64).apply();
} catch (Exception e) {
e.printStackTrace();
}
}
public static String getDecryptedData(String key) {
try {
SharedPreferences prefs = getSharedPreferences("secure_prefs", MODE_PRIVATE);
String base64 = prefs.getString(key, null);
if (base64 == null) return null;
byte[] encrypted = Base64.decode(base64, Base64.DEFAULT);
// 解密数据
return KeyStoreHelper.decrypt(encrypted);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}
```
### 2. 安全存储
使用安全的存储方式，避免明文存储敏感信息。
#### SharedPreferences安全使用
```java
// ❌ 错误：明文存储敏感信息
SharedPreferences prefs = getSharedPreferences("prefs", MODE_PRIVATE);
prefs.edit().putString("password", password).apply();
// ✅ 正确：加密后存储
String encryptedPassword = encrypt(password);
prefs.edit().putString("password", encryptedPassword).apply();
```
#### 使用EncryptedSharedPreferences（Android 6.0+）
```java
// 使用EncryptedSharedPreferences
MasterKey masterKey = new MasterKey.Builder(context)
.setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
.build();
SharedPreferences encryptedPrefs = EncryptedSharedPreferences.create(
context,
"encrypted_prefs",
masterKey,
EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
);
encryptedPrefs.edit()
.putString("sensitive_data", data)
.apply();
```
### 3. 数据清理
及时清理不再需要的敏感数据。
```java
// 清理敏感数据
public void clearSensitiveData() {
// 清理内存中的数据
password = null;
apiKey = null;
// 清理SharedPreferences
SharedPreferences prefs = getSharedPreferences("prefs", MODE_PRIVATE);
prefs.edit().clear().apply();
// 清理文件
File sensitiveFile = new File(getFilesDir(), "sensitive.txt");
if (sensitiveFile.exists()) {
// 安全删除：覆盖后删除
secureDelete(sensitiveFile);
}
}
// 安全删除文件
private void secureDelete(File file) {
if (file.exists()) {
// 覆盖文件内容
RandomAccessFile raf = new RandomAccessFile(file, "rws");
raf.setLength(0);
raf.close();
// 删除文件
file.delete();
}
}
```
### 4. 日志安全
避免在日志中输出敏感信息。
```java
// ❌ 错误：日志中输出敏感信息
Log.d("TAG", "User password: " + password);
Log.d("TAG", "API key: " + apiKey);
Log.d("TAG", "User token: " + token);
// ✅ 正确：敏感信息脱敏或移除
Log.d("TAG", "User login attempt");
// 或使用条件编译
if (BuildConfig.DEBUG) {
Log.d("TAG", "Debug info: " + debugInfo);
}
```
### 5. 内存安全
避免在内存中长时间保存敏感数据。
```java
// 使用后立即清理
public void processSensitiveData(String data) {
try {
// 处理数据
process(data);
} finally {
// 清理内存
data = null;
System.gc(); // 建议垃圾回收
}
}
// 使用char[]而不是String存储密码（可被清理）
public void handlePassword(char[] password) {
try {
// 使用密码
authenticate(password);
} finally {
// 清理密码
Arrays.fill(password, '\0');
}
}
```
---
## 网络安全
### 1. HTTPS通信
使用HTTPS进行网络通信，避免HTTP明文传输。
#### 配置网络安全
```xml
<!-- res/xml/network_security_config.xml -->
<network-security-config>
<!-- 默认配置：只允许HTTPS -->
<base-config cleartextTrafficPermitted="false">
<trust-anchors>
<certificates src="system" />
</trust-anchors>
</base-config>
<!-- 特定域名配置 -->
<domain-config cleartextTrafficPermitted="false">
<domain includeSubdomains="true">example.com</domain>
<trust-anchors>
<certificates src="system" />
<!-- 自定义证书 -->
<certificates src="@raw/my_ca" />
</trust-anchors>
</domain-config>
</network-security-config>
```
```xml
<!-- AndroidManifest.xml -->
<application
android:networkSecurityConfig="@xml/network_security_config"
... />
```
#### 证书固定（Certificate Pinning）
```xml
<!-- 证书固定配置 -->
<domain-config>
<domain includeSubdomains="true">api.example.com</domain>
<pin-set expiration="2025-12-31">
<!-- SHA-256指纹 -->
<pin digest="SHA-256">base64==</pin>
<!-- 备用证书 -->
<pin digest="SHA-256">base64==</pin>
</pin-set>
</domain-config>
```
### 2. 输入验证
验证所有网络输入，防止注入攻击。
```java
// 输入验证
public class InputValidator {
// 验证URL
public static boolean isValidUrl(String url) {
if (url == null || url.isEmpty()) {
return false;
}
try {
URL urlObj = new URL(url);
// 只允许HTTPS
return "https".equals(urlObj.getProtocol());
} catch (MalformedURLException e) {
return false;
}
}
// 验证输入长度
public static boolean isValidLength(String input, int maxLength) {
return input != null && input.length() <= maxLength;
}
// 验证输入格式
public static boolean isValidEmail(String email) {
if (email == null || email.isEmpty()) {
return false;
}
String pattern = "^[A-Za-z0-9+_.-]+@(.+)$";
return email.matches(pattern);
}
// 防止SQL注入
public static String sanitizeSql(String input) {
if (input == null) return "";
// 转义特殊字符
return input.replace("'", "''")
.replace(";", "")
.replace("--", "");
}
}
```
### 3. 请求签名
对重要请求进行签名，防止篡改。
```java
// 请求签名
public class RequestSigner {
public static String signRequest(String data, String secret) {
try {
Mac mac = Mac.getInstance("HmacSHA256");
SecretKeySpec secretKey = new SecretKeySpec(
secret.getBytes(), "HmacSHA256");
mac.init(secretKey);
byte[] hash = mac.doFinal(data.getBytes());
return Base64.encodeToString(hash, Base64.NO_WRAP);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static boolean verifyRequest(String data, String signature, String secret) {
String calculatedSignature = signRequest(data, secret);
return signature != null && signature.equals(calculatedSignature);
}
}
```
### 4. 超时和重试
设置合理的超时和重试机制。
```java
// 配置OkHttp超时
OkHttpClient client = new OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.writeTimeout(30, TimeUnit.SECONDS)
.build();
```
### 5. 敏感信息传输
避免在URL或请求头中传输敏感信息。
```java
// ❌ 错误：敏感信息在URL中
String url = "https://api.example.com/login?username=user&password=pass";
// ✅ 正确：使用POST请求体
RequestBody body = new FormBody.Builder()
.add("username", username)
.add("password", password)
.build();
Request request = new Request.Builder()
.url("https://api.example.com/login")
.post(body)
.build();
```
---
## 代码安全
### 1. 组件安全
正确配置组件权限和导出状态。
#### Activity安全配置
```xml
<!-- AndroidManifest.xml -->
<!-- ❌ 错误：导出且无权限保护 -->
<activity
android:name=".SensitiveActivity"
android:exported="true" />
<!-- ✅ 正确：不导出或设置权限 -->
<activity
android:name=".SensitiveActivity"
android:exported="false"
android:permission="com.example.PERMISSION" />
```
#### Service安全配置
```xml
<!-- Service安全配置 -->
<service
android:name=".MyService"
android:exported="false"
android:permission="com.example.SERVICE_PERMISSION" />
```
#### BroadcastReceiver安全配置
```xml
<!-- 动态注册更安全 -->
<!-- 静态注册需要设置权限 -->
<receiver
android:name=".MyReceiver"
android:exported="false"
android:permission="com.example.BROADCAST_PERMISSION">
<intent-filter>
<action android:name="com.example.ACTION" />
</intent-filter>
</receiver>
```
#### ContentProvider安全配置
```xml
<!-- ContentProvider安全配置 -->
<provider
android:name=".MyProvider"
android:authorities="com.example.provider"
android:exported="false"
android:readPermission="com.example.READ_PERMISSION"
android:writePermission="com.example.WRITE_PERMISSION" />
```
### 2. Intent安全
验证Intent的来源和内容。
```java
// Intent安全处理
public class IntentValidator {
// 验证Intent来源
public static boolean isValidIntent(Intent intent) {
// 检查组件是否存在
ComponentName component = intent.getComponent();
if (component == null) {
return false;
}
// 验证包名
String packageName = component.getPackageName();
if (!packageName.equals(getPackageName())) {
return false;
}
return true;
}
// 验证Intent数据
public static boolean isValidIntentData(Intent intent) {
Uri data = intent.getData();
if (data == null) {
return false;
}
// 验证scheme
String scheme = data.getScheme();
if (!"https".equals(scheme) && !"content".equals(scheme)) {
return false;
}
return true;
}
// 安全启动Activity
public static void startActivitySafely(Context context, Intent intent) {
if (isValidIntent(intent) && isValidIntentData(intent)) {
context.startActivity(intent);
} else {
// 记录安全事件
Log.w("Security", "Invalid intent blocked");
}
}
}
```
### 3. 代码混淆
使用ProGuard或R8进行代码混淆。
#### ProGuard配置
```proguard
# proguard-rules.pro
# 保留必要的类
-keep class com.example.model.** { *; }
# 移除日志
-assumenosideeffects class android.util.Log {
public static *** d(...);
public static *** v(...);
}
# 混淆配置
-dontpreverify
-repackageclasses ''
-allowaccessmodification
-optimizations !code/simplification/arithmetic
```
#### build.gradle配置
```gradle
android {
buildTypes {
release {
minifyEnabled true
shrinkResources true
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'),
'proguard-rules.pro'
}
}
}
```
### 4. 反调试保护
防止应用被调试和分析。
```java
// 检测调试器
public class AntiDebug {
public static boolean isDebugging() {
// 检查调试标志
if (Debug.isDebuggerConnected()) {
return true;
}
// 检查tracerpid
try {
BufferedReader reader = new BufferedReader(
new FileReader("/proc/self/status"));
String line;
while ((line = reader.readLine()) != null) {
if (line.startsWith("TracerPid:")) {
int tracerPid = Integer.parseInt(line.split("\\s+")[1]);
if (tracerPid != 0) {
return true;
}
}
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
// 检测模拟器
public static boolean isEmulator() {
return Build.FINGERPRINT.startsWith("generic")
|| Build.FINGERPRINT.startsWith("unknown")
|| Build.MODEL.contains("google_sdk")
|| Build.MODEL.contains("Emulator")
|| Build.MODEL.contains("Android SDK built for x86")
|| Build.MANUFACTURER.contains("Genymotion")
|| (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic"))
|| "google_sdk".equals(Build.PRODUCT);
}
}
```
### 5. 输入验证
验证所有用户输入，防止注入攻击。
```java
// 输入验证工具
public class InputValidator {
// 验证文件名
public static boolean isValidFileName(String fileName) {
if (fileName == null || fileName.isEmpty()) {
return false;
}
// 防止路径遍历
if (fileName.contains("..") || fileName.contains("/") || fileName.contains("\\")) {
return false;
}
return true;
}
// 验证JSON
public static boolean isValidJson(String json) {
try {
new JSONObject(json);
return true;
} catch (JSONException e) {
return false;
}
}
// 验证XML
public static boolean isValidXml(String xml) {
try {
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
factory.setNamespaceAware(true);
XmlPullParser parser = factory.newPullParser();
parser.setInput(new StringReader(xml));
while (parser.next() != XmlPullParser.END_DOCUMENT) {
// 解析XML
}
return true;
} catch (Exception e) {
return false;
}
}
}
```
---
## 安全测试
### 1. 静态代码分析
使用工具进行静态代码分析，发现潜在安全问题。
#### 使用工具
- **Android Lint**：Android官方代码检查工具
- **FindBugs/SpotBugs**：Java代码缺陷检测
- **SonarQube**：代码质量分析平台
- **Checkmarx**：安全漏洞扫描
#### Lint配置
```gradle
android {
lintOptions {
// 将警告视为错误
warningsAsErrors true
// 检查所有问题
checkAllWarnings true
// 忽略某些警告
disable 'UnusedResources'
// 输出报告
htmlReport true
htmlOutput file("$project.buildDir/reports/lint/lint.html")
}
}
```
### 2. 动态安全测试
在运行时测试应用的安全性。
#### 权限测试
```java
// 测试权限检查
@Test
public void testPermissionCheck() {
// 测试权限未授予时的行为
when(ContextCompat.checkSelfPermission(any(), anyString()))
.thenReturn(PackageManager.PERMISSION_DENIED);
// 验证应用正确处理权限拒绝
assertFalse(hasPermission());
}
```
#### 网络安全测试
```java
// 测试HTTPS连接
@Test
public void testHttpsConnection() {
// 验证只使用HTTPS
String url = getApiUrl();
assertTrue(url.startsWith("https://"));
// 测试证书验证
// ...
}
```
### 3. 渗透测试
模拟攻击者进行渗透测试。
#### 测试项目
- **组件导出测试**：检查是否有不必要的组件导出
- **权限测试**：测试权限是否正确配置
- **数据泄露测试**：检查是否有敏感信息泄露
- **注入攻击测试**：测试SQL注入、XSS等
- **加密测试**：验证数据是否正确加密
### 4. 安全审计
定期进行安全审计。
#### 审计清单
- [ ] 权限使用是否合理
- [ ] 敏感数据是否加密
- [ ] 网络通信是否使用HTTPS
- [ ] 组件是否正确配置
- [ ] 输入是否验证
- [ ] 日志是否包含敏感信息
- [ ] 代码是否混淆
- [ ] 依赖库是否安全
### 5. 漏洞扫描
使用自动化工具扫描已知漏洞。
#### 工具推荐
- **OWASP Mobile Top 10**：移动应用安全风险清单
- **MobSF (Mobile Security Framework)**：移动应用安全测试框架
- **QARK (Quick Android Review Kit)**：Android应用安全分析工具
---
## 总结
Android应用安全是一个持续的过程，需要：
1. **遵循安全原则**：最小权限、纵深防御、安全设计
2. **保护数据安全**：加密存储、安全传输、及时清理
3. **确保网络安全**：HTTPS通信、输入验证、请求签名
4. **加强代码安全**：组件安全、代码混淆、输入验证
5. **进行安全测试**：静态分析、动态测试、渗透测试
建议：
- 定期进行安全审计
- 关注安全更新和漏洞公告
- 使用官方推荐的安全实践
- 参与安全社区，学习最新安全知识
---
*最后更新：2024年*
Reference in New Issue Copy Permalink