|
/ Z( V5 z. M# j
一、前言好久没有更新帖子了，最近一直都比较忙，这里首先祝大家元旦快乐本文主要围绕Android APP漏洞中的信息泄露漏洞展开描述，因为挖掘Android APP信息泄露漏洞的思路各有差异，所以本文只是基于Android APP中较为基础的信息泄露的漏洞实例开始讲述。
9 Y* O8 z D( P! m4 m8 S* {: N 本文第二节主要讲述Android中存储的基本方式本文第三节主要讲述信息泄露漏洞的分类本文第四节主要讲述漏洞的原因和具体复现二、基础知识APP 信息泄露漏洞往往和Android APP的数据存储方式有关，所以我们这里首先详细的了解Android的数据存储方式。
' K. @% @; g' P" S8 t/ Q 我们知道Android中数据存储的方式共有五种，分别为：文件存储、SharedPreferences、SQLite数据库存储、ContentProvider、网络存储1.文件存储  & I6 N) E0 k2 L! Q" Z3 Y
下面我们将结合上面的思维导图依次讲解（1）内部存储内部存储一般存储一些应用的数据，如apk、shareprefence、database数据、webview缓存和图片缓存等等，内部存储一般存储在/data/下面，这些都需要用户获得root权限后才能访问到 
7 j( r0 U1 [/ N# E h, l 我们以root权限的模式进入：  ! D0 | Y0 _) I; k2 p8 y( b8 c
下面我们介绍常见的一些内部存储目录：/data/app/ 存储着我们手机上安装的apk文件% h7 E8 }& w T) X% u
/data/data/包名/share_prefs 存储对应的应用程序中的shareprefence存储文件' b; a. g. q+ P. H4 f9 D! w
/data/data/包名/cache 存储对应的应用程序中的cache缓存文件7 N$ ?3 A* K1 x; k0 b
/data/data/包名/databases 存储对应的应用程序中的数据库文件
$ C8 e* B7 E% Q$ H /data/data/包名/files 存储对应的应用程序中的资源文件 4 Y+ v4 Q: A% z
内部存储的特点：内部存储的文件和目录只能被我们的app自己所访问，别的app不能访问# e3 D- B1 g: T. N! j2 F8 F
内部存储中的私有目录，当用户卸载app之后，改文件目录中关于该应用的信息就会被删除
, m% l) Z6 x" T' q 内部存储是可用的( f" X) {) J6 l9 ]) c
内部存储大小有限，不适合存储大量数据。 . n1 q& z% s7 t9 s! t6 e1 N
3 H7 R; ?7 ^2 Z) L1 W% x 只有root的手机，才能从手机文件管理器看见，否则都是隐藏着的（2）外部存储Android4.4以前，手机自身的存储就叫内部存储，插入SD卡的存储叫外部存储，然而Android 4.4以后，手机自带的存储很大，因此现在的外部存储分为两部分：SD卡和扩展卡内存。
; a9 w, j- n$ G8 x6 X2 @ 外部存储一般分为两类，私有目录和公有目录，私有目录里面的数据会随着应用的卸载而删除，公有目录并不会自身的外部存储目录：/storage/emulated/0/Android/data/packagename/files
; k$ w! d! b' u: D+ O8 T& j 存储卡的存储目录：/storage/extSdCard/Android/data/packagename/files 
2 I: x5 J7 y1 O1 D 外部存储的特点：公有目录任何程序都可以访问，私有目录自身可以访问
' n$ o a5 D& U. i 并不一定是可用的，因为SD卡会被挂载& @, j% K3 ?0 Q( A" N" Z9 S' p
外部存储中的私有目录中的数据会随着应用的卸载而删除，公有目录则不会 私有目录私有目录，在Android 4.4以上，不需要注册和用户授权SD读写的权限，就可以在应用的私有目录进行读写文件，文件不能被其他应用访问，用户删除应用时，对应的应用的私有目录也会被删除。 ; [$ O4 k7 i# g! z
私有目录地址：/storage/emulated/0/Android/data/packagename相关API:私有目录访问的API都在ContextWrapper对象上，可以直接通过Activity或Context进行调用 $ E6 x4 N2 r; U! I$ s3 R8 O
getExternalCacheDir()： 访问/storage/emulated/0/Android/data/应用包名/cache目录，该目录用来存放应用的缓存文件，当我们通过应用删除缓存文件的时候，该目录下的文件会被清除
7 `' U3 `' m8 f$ R7 P5 s getExternalFilesDir(): 访问/storage/emulated/0/Android/data/应用包名/files 目录,该目录用来存放应用的数据 % g) p# c o- j& V7 P# f
公共目录公共目录必须需要用户授权读写的权限，就意味需要在AndroidManifest.xml中注册用户权限# w) H' @2 _+ A
% \2 c# ^, |9 H1 q/ E# w " o; l' r$ `7 b0 h& x3 H
Android 6.0系统之后需要申请用户权限，并获得用户授权，才能读写文件，公共目录相对开放，我们可以访问其他APP存在公共目录下的文件，并且当APP被删除时，并不会删除应用存在公共目录下的文件相关API: * m6 a# m5 I- F3 l: C
公共目录可以通过Environment对象，访问读写公共目录的文件Environment.getExternalStorageDirectory() 访问外部存储设备公共根目录# f, _2 U2 F- T( G
Environment.getExternalStorageState() 获得外部存储SD卡的状态
* l- ]" C) c" M （3）系统存储目录getRootDirectory()：对应获取系统分区根路径:/system
7 ?# Y; F. d; J5 c3 z getDataDirectory()：对应获取用户数据目录路径:/data7 {; x4 A$ r5 W* O1 W1 F X$ ~% f
getDownloadCacheDirectory()：对应获取用户缓存目录路径:/cache " J1 P# q8 T" [. K
补充：（1）升级应用程序后的apk文件在哪？* H9 t7 F6 F' T2 Z! U- R- \
一般我们从服务器端下载的app需要放到外部存储目录下面，而不是内部存储目录，即/storage/emulated/0/Android/data/packagename下' f' o! N! f/ W/ `* h/ D7 ~! u. Y1 T% ?
（2）清除数据和清除缓存的区别？
0 [9 l4 g! f! ^9 h# g 清除数据清除的是保存在app中所有数据，就是上面提到的位于packagename下面的所有文件，包含内部存储(/data/data/packagename/)和外部存储(/storage/emulated/0/Android/data/packagename/)，但不会影响SD卡的数据缓存是程序运行时的临时存储空间，缓存文件存放在getCacheDir()或者 getExternalCacheDir()路径下
" }9 o2 W% A. Q; a; u, y （4）文件存储的读写方式写入文件：public void save(){
+ b; q! @2 w6 z! x String data = "Data to save";
+ Q( W: S) o: u5 B! f$ q FileOutputStream out = null;
4 R# q6 k4 C2 q: p- o1 K ButteredWriter writer = null;
8 x9 U3 _# r4 {8 |) |/ V6 e G* H try{
/ p1 Q" p& p# d- c out = openFileOutput("data",Context.MODE_PRIVATE); //MODE_PRIVATE（默认）：覆盖、MODE_APPEND：追加
9 M) v! |" h' k0 d2 q+ N writer = new ButteredWriter(new OutputSreamWriter(out));
: ~9 m/ F9 i6 l% e1 |- D writer.write(data);
' X/ _3 l! r# J/ \9 ^; M% G1 ~ }catch(IOException e){. ^* d0 J) Z* F7 f, d8 k8 \
e.printStackTrace();& g% B, A5 ^. r8 M; w, z
}finally{
8 B( u6 ^) x" h4 V. X( z% L/ B1 T try{. o$ B% X% X% X
if(writer!=null){& Q# B4 S+ z5 t6 L
writer.close();
& } A* s* Y3 ~+ W# z" o* B }
* B2 y8 b5 y; ?3 W }catch(IOException e){, g* d* ~ ^0 r) c/ ?. x
e.printStackTrace();
, g( a. E' _. L4 j- F% W+ F }
- o4 y5 c' U+ @& t }
. z6 Y; j0 J1 Y. J! c5 k 读取文件：public String load(){5 _( b# q" w+ _8 u& m: E1 z2 U, f
FileInputStream in = null;1 u0 U. v O. i
ButteredReader reader = null;
8 p G% q; [! ]! {7 ]6 j8 j StringBuilder builder = new StringBuilder();
: g: o& i T7 u2 L try{
+ e' R0 D" [: H. C# e in = openFileInput("data");
- A; b% ]1 }% y; ~ reader = new ButteredReader(new InputStreamReader(in));
+ X/ F1 e" M3 X6 J# n% o+ z String line= "";
9 p8 Y8 C d# a8 \5 K" j while((line = reader.readline()) != null){
9 B6 `- d! e4 b! W8 {# C$ k$ w+ { builder.append();6 b6 z% W/ j6 X! G# i" `
}! v) y4 J. L/ t
}catch(IOException e){
6 V4 }. p! R! V( S4 B e.printStackTrace();3 i2 Y6 P: {; p3 f8 {3 Y
}finally{7 f4 C3 Q2 b. a( ^" C
if(reader != null){
) D/ L7 p; V# {+ h try{ {& i4 e* N. c8 C1 T B4 a. T7 h
reader.close();
7 f" ^" l& j0 [ }catch(IOException e){) O1 M5 i& d( g. X2 s r6 M% F
e.printStackTrace();0 A- U! \9 h; d6 f$ `9 c. F
}
0 C% |9 _& V3 l1 u6 B4 G }5 d* N* n, l/ }4 Q% ?# R
}$ a# J" r3 v% P" W# A8 a% [# r9 K5 \
}
- P' f' r; S$ e$ K, A3 [3 g 2.SharedPreferencesSharedPreference是Android平台上一个轻量级的存储类，主要是保存一些常用的配置比如窗口状态，是使用键值对的方式来存储数据，这样就可以支持多种不同的数据类型存储，进行数据持久化就会比文件方便很多
) e0 V% c4 o2 Q n 默认存储路径：/data/data/packageName/shared_prefs获取SharedPreferences对象的方法Context的getSharedPreferences()方法，参数一是文件名，参数二是操作模式
# V/ | K: L2 ] Activity的getPreferences()方法，参数为操作模式，使用当前应用程序包名为文件名4 c1 d# c( _1 _9 b% e/ n, X* Z
PreferenceManager的getDefaultSharedPreferences()静态方法，接收Context参数，使用当前应用程序包名为文件名 7 m* w T) ~9 o% J* s5 H
（1）SharedPreferences数据的存取SharedPreference的存储：(1)根据Context获取SharedPreferences对象! F4 n: ]' ?8 |1 ^$ o' b0 [
(2)利用edit()方法获取Editor对象, M7 y- C, x- r: m' i. I
(3)ditor对象存储key-value键值对数据: D+ o3 Y8 q* k. Y, O
(4)apply()提交数据
9 r( m# w' [- c+ ?, Q8 | public class MainActivity extends Activity {
- M! p! `. M. s+ d/ ] @Override
' w4 Q2 {5 o" k; B* } public void onCreate(Bundle savedInstanceState) {
% |% @7 U. J9 \& i+ t7 b super.onCreate(savedInstanceState);& Y7 ]3 j; B: Y6 q
setContentView(R.layout.main);
t/ r/ v5 S- B5 p' R. r7 h7 ~, A2 Z5 b' n
//获取SharedPreferences对象, w G' x) Y# Z6 u+ P! o8 m4 [* m
Context ctx = MainActivity.this;& B8 y6 P5 v0 d h
SharedPreferences sp = ctx.getSharedPreferences("SP", MODE_PRIVATE); //MODE_PRIVATE（默认）：只有当前的应用程序才能对文件进行读写、MODE_MULTI_PROCESS：用于多个进程对同一个SharedPreferences进行读写
5 w" J" d+ X& p //存入数据
4 n6 ~& e2 Y4 k. M& o Editor editor = sp.edit();
. v8 C7 b! M8 a2 y editor.putString("name", "Tom");* i+ m2 F5 y! d. C9 R
editor.putInt("age", 28);7 L; l) ~; W) r- m: O% ?
editor.putBoolean("married", true);9 ^* L3 F( b$ f# u6 ?, |+ V. o4 H; M
editor.apply();" {% K& [+ {% T# e z0 m& w* @. U
) P9 g" g+ s4 T" g' h/ g
//返回STRING_KEY的值$ y: I# Z5 ]- l# i8 `# S
Log.d("SP", sp.getString("name", "none"));) I2 `6 z7 `. G2 U
//如果NOT_EXIST不存在，则返回值为"none"% i7 ^: U0 Y) e' I& |% Q
Log.d("SP", sp.getString("NOT_EXIST", "none"));
% I: x0 r1 E1 _4 R, H* P7 o7 @) ^ }6 z8 |7 K0 H2 n+ a: O G$ }
, }! H$ l( X3 K' u2 [; m
} 9 m5 I; X r5 j# l& n' x
SharedPreference数据的读取：SharedPreferences pref = getSharedPreferences("data",MODE_PRIVATE);
0 `6 z+ \) }: N( ^4 [ String name = pref.getString("name");4 {6 d8 k0 }# b
int age = pref.getInt("age");/ `$ V( n# {! |
boolean isMarried = pref.getBoolean("isMarried"); ! V6 p+ E0 j& D, G5 {+ g+ f
3. SQLite数据库存储SharedPreferences对象与SQLite数据库相比，免去了创建数据库、创建表、写SQL语句等操作，但是其只能存储boolean，int，float，long和String五种简单的数据类型，而且SharedPreferences是以明文的形式存储密钥信息，往往存在一定的安全隐患。 3 j6 G) u7 a% K: x
为此Android还提供了一个轻量级的数据库SQLite数据库，SQLite是轻量级嵌入式数据库引擎，它支持 SQL 语言，并且只利用很少的内存就有很好的性能默认存储路径：/data/data/packagename/databases
' ?% r% S0 C4 p# k$ r （1）数据库的创建Android 提供了SQLiteOpenHelper类帮助创建和升级数据库，SQLiteOpenHelper子类至少需要实现三个方法：1.构造函数，调用父类SQLiteOpenHelper的构造函数。 8 [3 D1 ]* u! I6 R: X$ j
需要四个参数（上下文环境、数据库名称、查询数据的游标Cursor(通常为null)、当前数据库的版本号）- _8 [7 e( Q7 p/ h" s* R
2.onCreate（）方法，它需要一个 SQLiteDatabase 对象作为参数，根据需要对这个对象填充表和初始化数据# D( g5 w+ z* g+ a# V: ?
3.onUpgrage() 方法，它需要三个参数，一个 SQLiteDatabase 对象，一个旧的版本号和一个新的版本号，这样就可以方便的实现数据库的升级。 ' G3 \$ Y* [( M T
继承 SQLiteOpenHelper 创建数据库public class MyDatabaseHelper extends SQLiteOpenHelper {
! C N: _3 f' P- ] //1.构造方法7 ~( Z" w% ~" d! y- x* a' r
MyDatabaseHelper(Context context, String name, CursorFactory cursorFactory, int version)
, o5 b) ~+ R7 \ {
" E% H. d Y0 W3 s super(context, name, cursorFactory, version);6 ^# a" ?) H: D" v$ ]
}# c/ r" e4 [& N$ L+ n5 x
* x7 F$ a; f* |7 T: }7 X3 e/ d
@Override
9 Y( b* c- T* u$ C public void onCreate(SQLiteDatabase db) {
7 U: L& U" l2 v // TODO 创建数据库后，对数据库的操作# F5 b7 O4 _0 A: x2 R5 }
}
+ v p8 A T/ L( T, Y7 |0 H8 n# K3 r
5 O. T- f; E1 Y5 J5 Z. R: W. K @Override' J/ j1 d( F w& c5 F
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
2 J/ P% _6 r8 T // TODO 升级数据库版本
2 v1 ]4 [3 _" z# O3 F }2 U1 J% V: z$ f/ d3 ~/ e4 u
. U/ _8 Y, V; G8 h @Override
/ |# b+ X3 T6 r/ F# D# O public void onOpen(SQLiteDatabase db) {
& A' ^4 |+ _; F super.onOpen(db);
9 k/ c3 N& |1 N8 O* v8 q // TODO 每次成功打开数据库后首先被执行
* y7 y0 D9 L- x }
- G' v& c0 B" T- _' |6 h } 8 j; A4 }+ F- N% y
（2）数据库的更新public class MyDatabaseHelper extends SQLiteOpenHelper{
* b, d0 u. e4 n* B$ L ......
$ C5 ~1 ]! t1 E //当打开数据库时传入的版本号与当前的版本号不同时会调用该方法
! ]0 W4 p" t: b7 Y e' _+ o* {6 L; C @Override! q: G4 g l A: c1 s0 `
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
9 J! q/ K* N% B* Z- ]( c6 k db.execSQL("drop table if exists Book");# ^, i+ b: r9 Y5 L
onCreate(db):) L5 c$ F6 j& V% @3 T
}% i$ a' e; K/ _
} . C' I; [% m$ h% }* E
只要我们在MainActivity中将version改为大于原来版本号，就可以让onUpgrade()方法得到执行MyDatabaseHelper helper = new MyDatabaseHelper(this,"BookStore.db",null,2);# ?& v9 ~$ c+ K; U
helper.getWritableDatabase();
* W. x* A. H$ V; n6 v3 A) | （3）数据库的基本操作添加数据：SQLiteDatabase db = helper.getWritableDatabase();2 a" o$ U6 j$ W$ Z
ContentValues values = new ContentValues();% r* e7 g' Z! _
values.put("name","The Book Name");
, o) K& g) A/ c2 ~ values.put("author","chen");8 v1 C% G b& ?/ n! m9 g$ h
values.put("pages",100);& r6 J! U P2 u( k. E/ k5 ?
values.put("price",200);
+ M. u8 n }; _2 Z- T6 e& t. n db.insert("Book",null,values);//参数一 表名 参数二 未指定添加数据的情况下为NULL 参数三 ContentValues对象
) d! X% j! j& m. v 更新数据：SQLiteDatabase db = helper.getWritableDatabase();
3 G- b$ I: N. [; ] ContentValues values = new ContentValues();( D e- c- s6 `8 T4 n
values.put("price",120);5 K, G* V- Y$ \* X9 a' k
db.update("Book",values,"name= ?",new String[]{"The Book Name"}); //参数一 表名 参数二 ContentValues对象 参数三、四是去约束更新某一行或某几行的数据，不指定默认更新所有
4 d4 P& F# S5 }' u' Y" V 删除数据：SQLiteDatabase db = helper.getWritableDatabase();
" {. K! ~$ d8 p1 _5 g9 b* Q db.delete("Book","pages> ?",new String[]{"100"}); //参数一是表名，参数二、三是去约束删除某一行或某几行的数据，不指定默认删除所有 " ? w/ p) E- }$ ~
查询数据：SQLiteDatabase db = helper.getWritableDatabase();1 G- S& L8 K4 Z9 q# N
//query()方法，参数一是表名，参数二是指定查询哪几列，默认全部，参数三、四是去约束查询某一行或某几行的数据，不指定默认查询所有，参数五是用于指定需要去group by的列，参数六是对group by的数据进一步的过滤，参数七是查询结果的排序方式 m: Z ^& K2 E$ P
Cursor cursor = db.query("Book",null,null,null,null,null,null);! z& D2 L* H9 v( L
if(cursor.moveToFirst()){7 K0 f" W. u9 x7 F
do{. _ k! Q9 s2 N0 [+ j m
String name = cursor.getString(cursor.getColumnIndex("name");
: c. P/ l# k t! t3 ^ String author = cursor.getString(cursor.getColumnIndex("author");& s. h6 p, q5 w0 t5 t* j( r
int pages = cursor.getString(cursor.getColumnIndex("pages");
& m- P* s' F l& ~7 y double price = cursor.getString(cursor.getColumnIndex("price");
) H8 e% K+ s" X }while(cursor.moveToNext());
& e1 m, ^' p( ?: v! x# q1 _$ J- ?7 H( Q }% l3 T7 O: z1 Z$ f
cursor.close();
, k5 X7 B4 W: h; Q7 X; G, N SQL语句操作数据库：//添加数据. S3 B5 X, v9 `, e: e$ l7 e$ I
db.execSQL("insert into Book(name,author,pages,price) values(?,?,?,?) "
) k, y2 E. [; \& ~" B% U ,new String[]{"The Book Name","chen",100,20});& F E Y3 a% X9 l% m
//更新数据
5 N; u! K% a s$ F5 ^4 u, l db.execSQL("update Book set price = ? where name = ?",new String[]
0 K' e f- Q. C' b: t H {"10","The Book Name"});6 ~2 z: I+ c: f3 A' B' O: C4 x" e
//删除数据! i1 s/ R& X: U! a& {8 l
db.execSQL("delete from Book where pages > ?",new String[]{"100"});/ P/ f: J$ K( `6 v+ C; P9 O
//查询数据
3 m0 u/ [" d; a Q db.execSQL("select * from Book",null);
' d$ p9 I/ D+ u5 I 5 g/ N0 X8 c6 D: v4 {
使用事务操作：SQLiteDatabase db = helper.getWritableDatabase();
& }' ?& f7 S6 K0 S# f db.beginTransaction(); //开启事务
9 O, {8 w9 Q0 J% B) m7 o5 p. W try{5 L8 w% a" o# }& g5 w" z4 R. Z9 ]
......
# h" A5 L# X* w' K& {% J db.insert("Book",null,values);, B0 u4 E) b" C% T+ b+ ~3 F% {
db.setTransactionSuccessful(); //事务成功执行; I$ R4 b8 ~7 n' u2 u
}catch(SQLException e){. P) J5 ^& @- V8 X. j
e.printStackTrace();3 ^3 k h; L# v$ N& U
}finally{
# ]. W1 ]. d& }: k+ f db.endTransaction(); //结束事务. f4 u" r7 V4 n/ A, x; K
} 8 H- c! F/ k7 a% A: V! T. y6 m
当然Android数据库中还包括LitePal数据库更加方便的操作，由于本文主要是介绍漏洞，所以这里就简单介绍到这里4. ContentProvider前面三种方式是Android中基本的存储方式，但是由于都存在一个公共的缺点：不能实现不同应用程序之间进行数据共享，大家都知道Android是采用沙箱的管理机制，不同的应用程序之间都是独立隔离开的，这一定程度上也是为了Android 应用之间的安全性考虑，但是如果应用之间不能很好的进行交互，那么很显然就带来了明显的不便，因此为了解决这个问题，内容提供器——ContentProvider就孕育而生了，由于前面我们有专门的章节讲述这一组件，所以本文只是简单描述，不详细了解，请参考Android APP漏洞之战（4）——Content Provider漏洞详解
! l1 P) L C0 L# ~0 c5 z. o2 E 主要作用：用于不同的程序之间实现数据共享的功能，并通过ContentResolver进行操作ContentResolver使用方法：（1）内容URI//包名为com.example.app的表table1访问路径
+ Q/ x% B- \& s n8 t K. i Uri uri = Uri.parse("content://com.example.app.provider/table1"); & k' H) q3 M8 M
（2）使用URI对象进行数据操作查询Cursor cursor = getContentResolver().query(uri,null,null,null,null);. E1 A/ ?) {6 h
if(cursor != null){) G: @1 w: f+ a3 }$ q: g
while(cursor.moveToNext()){
" U6 I6 h+ R# Y7 F1 X. o; M4 K String column1 = cursor.getString(cursor.getColumnIndex("column1"));, [. }9 O$ B }6 p- e
String column2 = cursor.getString(cursor.getColumnIndex("column2"));
9 @# Y" ^% Z- S- o5 d0 d }
9 s) q- t# A* O, |8 {) v6 @ cursor.close();& l: a* a$ O1 C( g
} ) i6 n+ p7 Q4 {8 l& b
插入ContentValues values = new ContentValues();' v! `; j) X; P. \
values.put("column1","text");
& |4 A6 ]: f* [8 d values.put("column2",1);
( g' p+ B. \! @ getContentResolver().insert(uri,values);
! s; n8 _0 a# S3 m' {# T. x 5.网络存储Android网络存储主要是通过网络来实现数据的存储和获取，这里主要调用WebService返回的数据或是解析HTTP协议实现网络数据交互，具体需要熟悉java.net.，Android.net. - o8 t- q3 o% J* p j/ T: T
这两个包的内容，因为不是Android的主流存储方式，这里主要参考相应文档即可，也不是本文漏洞所关注的主要对象，就不做过多叙述了网络存储需要开启权限：
! t0 b F) a8 u% X% b* Y' D- f& i/ Z 具体可参考本文参考文献三、信息泄露漏洞的安全场景和分类1.漏洞的安全场景信息泄露漏洞往往是指APP开发过程中一些不安全的开发问题导致敏感信息的泄露，那我们首先可以将敏感信息进行分类：产品敏感信息和用户敏感信息 ' x4 k0 Y I! ?/ q4 Q
（1）产品敏感信息产品敏感信息：登录密码、后台登录及数据库地址、服务器部署的绝对路径、内部ip、地址分配规则、网络拓扑、页面注释信息等（2）用户敏感信息用户的个人隐私信息泄露导致被恶意人员利用获取不当信息，例如用户的密码，账户信息等等
2 {; I+ Z' w/ {3 y 这些敏感信息泄露往往是由于信息未加密或存储位置不当造成：代码中明文使用敏感信息，比如：服务器地址、数据库信息等
' L4 k/ @1 W6 k: F! W 数据库中明文保存敏感信息，比如：账号、密码、银行卡等
/ J7 m% [: Y) p2 y% F( M1 d) e SD卡中保存敏感信息或隐私信息,比如：聊天记录、通讯录等
1 @6 r: S8 f' G7 P% l" i 日志打印敏感信息,比如：账号、密码
" m7 r: z8 c0 r! W( y' p: g 明文传输敏感信息
7 S) ^8 o! A/ \" ^ 2.漏洞的分类综上我们将Android中的信息泄露漏洞大致可分为：  # ^9 }, h! S( H+ Y! I3 A3 a
四、信息泄露漏洞的原理分析和复现本文为了简单演示各个漏洞的复现情况，将会使用样本DIVA.apk和一些实际漏洞的场景，样本将放到附件中1. LogCat输出敏感信息漏洞（1）原理分析在APP的开发过程中，为了方便调试，开发者通常会用logcat输出info、debug、error 等信息。 . `, n8 v P! S7 z0 ^+ i
如果在APP发布时没有去掉logcat信息，可能会导致攻击者通过查看logcat日志获得敏感信息一般来说，LogCat敏感信息输出漏洞包括：应用层Log敏感信息输出% |3 q3 x% H: z0 E8 h/ V
应用层System.out.println敏感信息输出- w C7 Z; U8 }# g" T' A* H
系统bug异常导致Log输出
1 B4 }# M- ~/ `% J( V Native层敏感Log输出 , P+ V' T1 A( |( ]' Y/ w) i
（2）漏洞案例——DIVA.apk例题1首先，我们安装样本DIVA.apk
$ y; {) E7 O: Q5 y 然后我们打开例题1，并开启日志监控adb logcat |grep diva 9 N) ^+ U( ?5 ]/ [
我们在app表单总输入内容，check out后查看相关日志
' X; V+ D) M2 ]3 r$ }9 j 我们就可以发现我们输入的密钥信息，然后我们根据日志信息，可以找到漏洞代码在LogActivity.class文件，我们查看相关代码： 6 b5 P) G! z& P- V3 a( K
这里相关代码就是将敏感信息给泄露，当然我们真实的app中不会这么简单，但这确实一个很好的思路，比如我们对我们分析的app中的敏感信息的函数进行hook或者通过插桩日志的信息，我们就可以成功获得敏感信息了 # R* a* Z7 g- \3 `- l$ T# ~
（3）安全防护防护建议：1.Android Studio中配置ProGuard实现release版apk自动删除Log.d()/v()等代码
- j7 j" {$ v+ e+ j 2.使用自定义LogCat类，上线前关闭LogCat开关, ~8 }$ M: L, G9 q# g$ P
public class LG{
& f6 q! T* d2 F+ e' {+ _ //是否开启debug
1 f; Q' A) t* b$ p! Z8 R public static boolean isDebug = true;
% e' l. `# }& `
: a! u: [7 b; u$ W public static void e(Class clazz,String msg){) I( H9 O4 I! r1 @
if (isDebug){# F3 [% J8 l7 o, G2 e. R5 V# P8 Q
//Log.e7 h/ }* Z* E6 L
}
+ u' O! n( }8 x+ D+ n }
0 r) x6 U. \4 D$ g. O6 w4 V0 N3 h2 h; N; w& U6 q' V, D x* k
public static void i(Class clazz,String msg){
3 M3 e9 B P6 a9 V if (isDebug){
2 N, ?8 T4 W0 R/ v' G- P7 y+ x) U //Log.i
. e# U i! Z9 L8 O) x3 r }: I l4 E6 y% w* q# p& x
}& |' m- }% u% S. Z! O% `
6 V6 W( S& D! [2 C" Z; f% y) v# x public static void w(Class clazz,String msg){* p, E4 W+ K5 h# X7 L
if (isDebug){
3 ?, H9 c# S9 e0 P/ @* T. m //Log.w
, ^" ]( w# G& Z* ^9 R }6 s$ Q, E* u1 ]: F
}- t7 a# F7 m* I* k* I- k
/ i9 q9 b. T) C! U0 H' s public static void d(Class clazz,String msg){$ u& _4 H& `6 }% A$ d4 E; Y* |+ w
if (isDebug){- @7 x; ~! ^& q. |( n, D
//Log.d- i0 C) F J3 S. Y0 j6 m- ~
}
# ?- Q! ^* n' }" B2 N) | }
) Q% W; E% r' Q. i8 H2 V% s } 1 t5 q7 @% t) P( B% n" T5 T
2.硬编码问题漏洞（1）原理分析一些开发人员，在开发时使用硬编码的方式，导致存在一定的安全风险，硬编码一般是指将输出或输入的相关参数以常量的方式编写在源代码中，这样导致逆向分析人员可以直接通过分析源码就可以获得敏感信息 0 d0 [% d& }: v; W, ]2 S
（2）漏洞案例——DIVA.apk例题2（java层）我们打开样本app的例题2
8 ~8 {( X. Y; P# C 我们分析对应app相关的逆向代码：
; K0 W4 `) H1 P6 ]; m3 X 我们可以发现相应的敏感信息被直接用来判断，采用硬编码的方式，我们直接将密钥输入，发现可以成功破译
3 W; c; `6 b8 r （3）漏洞案例——DIVA.apk例题12（so层）我们打开例题12 , G y4 U- {: U+ m3 X
我们分析对应的代码段
& _9 \& O8 g5 D9 Y% @ 说明key被保存在libsoName.so库中，我们将文件打开 ) e$ H g* e- S4 t2 F
经过分析，我们确定这就是我们的键值，我们输入 ' t, V5 S' v. r0 Q+ q
说明key放在so层中也是不安全的（4）安全防护1.对明文传输的密钥进行加密传输
8 C* z, p1 @7 V3 W& E 2.采用变量的方式去读取，不采用硬解码的方式
0 N# j4 O, Y% S+ q& ?- k5 ? 3.对java层中进行混淆，对so层中进行ollvm控制流混淆3. Shared Preference全局可读写漏洞
* [0 Q. Q% P3 p. D. M( X （1）原理分析Shared Preferences存储安全风险在于：开发者在创建文件时没有正确的选择合适的创建模式（MODE_PRIVATE、MODE_WOELD_READABLE以及MODE_WORLD_WRITEABBLE）进行权限控制，导致将一些用户信息、密码等敏感信息存储在Shared Preferences文件中，攻击者可以通过root来查看敏感信息
, I6 l8 V: B' e5 J5 D8 a+ M$ c （2）漏洞案例——DIVA.apk例题3我们进入例题3： + l$ y! @( H. D6 J: \8 ^, b1 {( H
我们分析对应的逆向代码： / s/ A2 \0 D" k% l% O5 L0 E) X; ]: q
经过我们前文的分析，很明显这里采用的是SharedPreference的存储方式我们输入相关的账号和密码，然后我们可以进入shared_prefs查看相关的文件
, j4 S `+ N% {+ Z （3）安全防护防护意见：1.避免使用MODEWORLDWRITEABLE和MODEWORLDREADABLE模式创建进程间通信的文件，此处即为Shared Preferences
6 J7 t+ \, }8 F! k2 N1 h" i 2.不要将密码等敏感信息存储在Shared Preferences等内部存储中0 F" ~" }' u# p* n0 c
3.避免滥用"Android:sharedUserId"属性
& R: \7 o8 o5 e( \; P) I 4.不要在使用“android:sharedUserId”属性的同时，对应用使用测试签名，否则其他应用拥有“android:sharedUserId"属性值和测试签名是，将会访问到内部存储文件数据
- B' t$ F3 F; g 5.使用Secure Preferences第三方加固库进行存储 1 K3 {) P3 K7 q. u$ ^
4.数据库存储漏洞（1）原理分析Database配置模式安全风险源于：开发者在创建数据库（Database）时没有正确的选取合适的创建模式（MODE_PRIVATE、MODE_WORLD_READABLE）进行权限控制，从而导致数据库（Database）内容被恶意读写，造成账户密码、身份信息、以及其他敏感信息泄露，甚至攻击者进一步实施恶意攻击 3 n- q9 x( L5 _4 o; @
（2）漏洞案例——DIVA.apk例题4我们进入例题4
3 w. A, r2 W9 `6 ^: D 然后我们输入相关信息并保存
3 v. k- R# L5 w5 w2 ^8 s& K 我们将数据库给拉取下来，然后使用SQLite查看 . p2 Y8 f, r* V. F _
我们就可以发现敏感信息，我们可以分析对应的代码段
9 ]- s) R) r/ {' f N 我们上文的存取数据库名也是从对应代码出找到（3）安全防护防护建议：1.敏感信息在进行数据库存储时，对数据进行加密存储，并且应该避免弱加密或者是不安全的加密方式* g0 g/ Q5 ?2 m" m2 l( Q. u
2.对于敏感的数据库文件，不得使用MODE_WORLD_READABLE或者是MODE_WORLD_WRITEABLE进行创建
; f8 `+ Z F8 c4 b; b 5.临时文件或SD卡漏洞（1）原理分析经过上文我们讲述的文件存储，现在的手机很多的公共目录都是自身自带的存储空间，Android系统的文件一般都存储在sdCard和应用的私有目录下，任何在Android Manifest中声明读写sdcard权限的应用都可以对sdcard进行读写。
& d) q2 T4 K% h6 r/ t" R （2）漏洞案例——DIVA.apk例题5与例题6我们打开例题5
; ?: B; u* O, }) _6 ~ 我们分析对应部分的相关代码：
& M6 J3 V' U1 V6 v' y 根据代码，我们知道这里采用文件存储的方式，所以我们直接找到该文件，查看即可
, I: v" H) {9 p% T9 M- [ 同理，我们打开例题6，查看对应的代码
, P' Q) a) S) A- M 我们可以发现是存储在sd卡下，然后我们输入相关信息，之后直接去sdcard下查找，这里我们需要注意，需要给应用存取权限，否则是保存不了的 7 I8 F. B$ ~+ t6 h- x; F. k8 e: c
（3）安全防护防护意见：1.不要将敏感信息存入本地固定的文件中，哪怕是加密存储也可能面临暴力破解的风险
. y6 F# T0 A4 v( t% ^! a0 ^ 2.对于保存信息的代码段进行混淆加密，使其难以被逆向人员简单分析获取6. http明文传输漏洞（1）漏洞原理
3 @5 _$ g$ R. \ 开发人员在开发时对网络连接的一些敏感数据往往采用http明文传输，这样就十分容易导致恶意攻击者通过一些抓包工具进行捕获，获取敏感信息，导致信息泄露的风险（2）漏洞案例——XX音乐存在任意文件下载漏洞这段时间我查看了一下国内主流的音乐软件平台，发现很多音乐软件都存在http明文传输的问题，这样势必会导致升级劫持、信息泄露、任意文件下载等等漏洞，这里我们列举一个有http明文泄露导致的任意文件下载问题
$ E5 Y/ H: d. E2 I 首先我们随便选择几首需要VIP下载的歌曲等他 ! P8 @- G. h/ o! }& u; R' H
我们发现这些音乐都需要开通VIP才能下载接下来我们用抓包软件抓取 % R* m; t" R, I! X9 k4 x& }
我们发现了音乐的url，我们直接访问，发现可以直接下载（3）安全防护防护建议：1.采用https加密传输
3 z9 Y- ~( q# {; Q 2.敏感信息使用http传输，那么对敏感信息进行加密，并且使用非对称加密，或者公认的强加密算法
% }4 P- r) D( ]7 g8 t- D" d 3.对以下字段进行加密处理：密码、手机号、快捷支付手机号、Email、身份证、银行卡、CVV码、有效期等
9 D9 R4 Q7 r* L J P& V& u 五、实验总结本文对Android App中信息泄露漏洞的常见形式做了一个基本的讲述，当然实际过程中很多APP的信息泄露漏洞可能要比这个复杂，这里只是初步的为大家介绍一下信息泄露漏洞的基础知识，本文的样例我会上传到github上，这里放一个传送门： 7 U. V/ \3 m+ `, g9 ~
github地址六、参考文献文件存储：https://juejin.cn/post/6844903778227847182#heading-10
; h; m0 O6 r( R4 N https://juejin.cn/post/6844904013515718664#heading-6 2 C3 [+ O5 k; m
其他存储：https://www.jianshu.com/p/536ca489a7f4
0 O& G, y) I: ^+ Q0 V https://cloud.tencent.com/developer/article/1045171网络存储：https://www.cnblogs.com/doodle777/p/4937594.html
. t4 A [; W$ R) L" k, i6 c https://blog.csdn.net/weixin_43689040/article/details/103761411 ) m% }; \5 |; f6 E. N @
漏洞挖掘参考：https://www.anquanke.com/post/id/84603
( b1 {# {$ ?6 }5 V2 X https://www.anquanke.com/post/id/86057本文由随风而行原创发布转载，请参考转载声明，注明出处： 2 t7 F2 ]2 D4 z8 w
https://www.anquanke.com/post/id/264824安全客 - 有思想的安全新媒体
3 H! b; ] a( |2 @
- ~2 \" O" {) b) h2 j$ n% h9 P8 p9 v+ r4 y# o7 l
. k& F7 ~/ a; t+ ~- S
# R. E! l- p, u+ I" a
| 
