Do as You Say: Consistency Detection of Data Practice in Program Code and Privacy Policy in Mini-App

TL;DR

This study systematically detects inconsistencies between data practices in mini-app code and their privacy policies, revealing a high rate of violations and proposing solutions to enhance privacy compliance.

Contribution

First to analyze and detect privacy policy and data practice inconsistencies in mini-apps using a customized taint analysis method for JavaScript.

Findings

89.4% of mini-apps have data practice and policy inconsistencies

318 out of 2,998 mini-apps meet consistency requirements

High potential for data leakage due to inconsistencies

Abstract

Mini-app is an emerging form of mobile application that combines web technology with native capabilities. Its features, e.g., no need to download and no installation, have made it popular rapidly. However, privacy issues that violate the laws or regulations are breeding in the swiftly expanding mini-app ecosystem. The consistency between what the mini-app does about the data in the program code and what it declares in its privacy policy description is important. But no work has systematically investigated the privacy problem of the mini-app before. In this paper, to our best knowledge, we are the first to conduct the compliance detection of data practice and policy description in mini-apps. In this paper, we first customize a taint analysis method based on data entity dependency network to adapt to the characteristics of the JavaScript language in the mini-apps. Then, we transform data types and data operations to data practices in program codes and privacy policies, so as to finish a fine-grained consistency matching model.We crawl 100,000 mini-apps on WeChat client in the wild and extract 2,998 with a privacy policy. Among them, only 318 meet the consistency requirements, 2,680 are inconsistent, and the proportion of inconsistencies is as high as 89.4%. The inconsistency in the mini-app is very serious. Based on 6 real-world cases analyzed, in order to reduce this potential data leakage risk, we suggest that the developer should reduce the collection of irrelevant information and the straightforward use of templates, and the platform should provide data flow detection tools and privacy policy writing support.

Tables

Table 1. Table 1. Privacy-related Entity Dictionary (Data Type)

Primary Category	Secondary Category	Num	Phrase	Num
Basic	name, birthday, gender, address, …	11	sex, city, mobile, …	352
Identify	ID card, passport, driver’s license, …	8	identity card, visa, …	72
Biometric	recognition features	1	touchId, fingerprint …	20
Network	account, password, photo, video, …	14	pwd, uid, album, …	271
Health	weight, medication records, …	6	hospital, doctor, …	62
WorkEducation	occupation, salary, organization, …	5	job, company, graduate …	108
Property	bank account, credit, transaction, …	6	order, income, payment, …	183
Communication	sms, address book, friends list, …	5	chatList, smsVerify, session, …	41
Web Log	log, browsing records, click record, …	5	search history, favorites list, …	140
Device	phone model, config, app	3	iOS, android, IMEI, sysinfo, …	78
Location	position, accommodation	2	gps, geographical location, …	99
Hardware	camera, recorder, bluetooth, …	11	wifi, nfc, ram, …	68
Other	marriage, express, travel	3	destination, departure date, …	53
Total		80		1547

Table 2. Table 2. Privacy-related Entity Dictionary (Data Operation)

Operation Category	Operation Words	Num
Collect	provide, acquire, read, collect, input, access, record, accept, shoot, scan, …	33
Use	process, display, store, pay, analyze, call, save, show, search, dail, …	42
Send	share, pass, transmit, upload, transfer, post, submit, spread, receive	9

Table 3. Table 3. Source APIs provided by WeChat platform

Category	Example	Num
System	wx.getSystemInfo, wx.getSystemInfoSync, env	3
Storage	wx.getStorage, wx.getStorageSync, wx.getStorageInfo, wx.getStorageInfoSync	4
Network	wx.getNetworkType, wx.request, wx.downloadFile, wx.onSocketMessage	5
Media	wx.getImageInfo, wx.chooseImage, wx.getVideoInfo, wx.openVideoEditor	26
Location	wx.chooseLocation, wx.getLocation, wx.onLocationChange	3
File	wx.getSavedFileList, wx.getFileInfo, wx.getSavedFileInfo	13
Share	wx.getShareInfo, wx.authPrivateMessage	2
Device	wx.getBeacons, wx.onBeaconSeviceChange, wx.onBLEPeripheralConnectionStateChanged	76
Open Interface	wx.login, wx.getAccountInfoSync, wx.addCard	16
Lifecycle	wx.getEnterOptionsSync, wx.getLaunchOptionSync	2
Total		150

Table 4. Table 4. Sink APIs provided by WeChat platform

Category	Example	Num
Usage	wx.setStorage, wx.saveFile, wx.showToast, wx.saveImageToPhotosAlbum, console.log, …	120
Transmission	wx.request, wx.uploadFile, wx.requestPayment, wx.connectSocket, wx.sendSocketMessage, …	31

Table 5. Table 5. Taint analysis results, including data flow distribution (based on source) and manual inspection results.

Mini-App Name	Flow Distribution (based on source)				Inspection
	Sync. API	Async. API	UI	All	Right	Broken	Wrong
998 Excavator	3	192	77	272	260	12	0
CMC Theater	2	38	7	47	46	1	0
Hi Repair	28	52	16	96	55	42	0
BaiKa Butler	0	6	3	9	7	2	0
Animated Universe	52	18	60	130	92	38	0
Registration Assistant$\ast$	1	2	0	3	3	0	0
Hand Over Cards$\ast$	9	20	34	63	63	0	0
Total	95	328	197	620	526	94	0
$\ast$ These codes are obfuscated and the abstract syntax tree structure is broken.

Table 6. Table 6. Sentences classification result

One-hot Vocabulary	Model	Accuracy	Recall	F1 Score
Type	MLP	0.9578	0.7944	0.8669
	CNN	0.9506	0.8043	0.8492
	LSTM	0.8815	0.4971	0.5920
Type&Operation	MLP	0.9798	0.9256	0.9408
	CNN	0.9725	0.9021	0.9189
	LSTM	0.8936	0.4990	0.6187
Type*Operation	MLP	0.9695	0.8412	0.9053
	CNN	0.8598	0.1896	0.3188
	LSTM	0.9037	0.5861	0.6780

Table 7. Table 7. Cases from the dataset.

Basic Information	Data practice*		Inconsistency
ID#Name #Downloads#Category	Program Code	Privacy Policy	Pattern (Data Practice)	Strength
1#Hui Charging #40704#Service	(camera, C&U&S),(request return, C&U&S), (login credentials, C&U&S),(location, C&U), (photo, C&S), (phone number, C&U), (sms, C&U), (password, C&U), (browsing records, C&U), (address, Ct&U)	-	Overlap(Uninformed)	Strong
2#KuaiShao #4598#Tool	(location,C&U),(phone number,C&U)	(account,U),(password,U),(express,U)	Seperation	Strong
3#Hangzhou Machinery Application Platform #<100#Government	(location, C&U)	(account,U), (password, U)	Seperation	Strong
4#Smart Canteen #<100#Service	(request return, C&U), (address, C&U), (click record, C&U)	(account,U),(password,U), (address, U), (e-mail, U)	Intersection	Strong&Weak
5#MeiYou #80743#Service	(request return,C&U),(setting, C&U), (browing records, C&U),(phone number, C&U)	(phone number,C&U),(e-mail, C&U), (nick name, U), (icon, U), (app list, U), (menstruation, C&U), (browsing records, C&U), (personal name, U)	Intersection	Strong
6#HuoShuiBao#<100#Service	-	-	Overlap(Consistent)	-
*Data practices with the same data type have been merged. For the data operations, ”C” represents ”Collect”, ”U” represents ”Use” and ”S” represents ”Send”.
- means the result is empty.

Table 8. Table 8. Javascript analysis tools comparison

Tool	Availabel Interfaces			Supportive
	Control Flow Analysis	Dependency Resolution	Data Flow Analysis	Web1	Node2	Mini-app
TAJS	✓	✓	✓	✓	$\times$	$\times$
JSAI	$\times$	$\times$	$\times$	✓	$\times$	$\times$
SAFE	✓	$\times$	$\times$	✓	✓	$\times$
JsPrime	$\times$	✓	✓	✓	✓	$\times$
CodeQL-Js	✓	✓	✓	✓	✓	$\times$
JsFlow	$\times$	$\times$	✓	✓	$\times$	$\times$
Understand-Js	✓	✓	$\times$	✓	✓	$\times$
1. The web application processes HTML files, based on the DOM interface, and runs in a browser environment.
2. The node application is based on Chrome JavaScript, event-driven, and runs on the server.

Full text

To achieve this purpose, there are two main challenges. First, the mini-app is a novel form of application, and there lacks an effective tool to support us directly in obtaining the accurate data practice from code. Second, past consistency works have coarse-grained issues on data types, data operations, and consistency patterns. In this paper, we first customize a taint analysis method based on data entity dependency network to adapt to the characteristics of the JavaScript language in the mini-apps. Then, we transform data types and data operations to data practices in program codes and privacy policies, so as to finish a fine-grained consistency matching model.

We crawl 100,000 mini-apps on WeChat client in the wild and extract 2,998 with a privacy policy. Among them, only 318 meet the consistency requirements, 2,680 are inconsistent, and the proportion of inconsistencies is as high as 89.4$\%$. The inconsistency in the mini-app is very serious. Based on 6 real-world cases analyzed, in order to reduce this potential data leakage risk, we suggest that the developer should reduce the collection of irrelevant information and the straightforward use of templates, and the platform should provide data flow detection tools and privacy policy writing support. 111New Paper

mini-app, compliance, consistency, privacy

††copyright: acmcopyright††journalyear: 2022††doi: XXXXXXX.XXXXXXX††copyright: none††conference: ; XXX; ††price: 15.00††isbn: 978-1-4503-XXXX-X/18/06††ccs: Software and its engineering Software notations and tools††ccs: Security and privacy Software and application security††ccs: Security and privacy Privacy protections

1. Introduction

A new format of mobile application, called mini-app(min, 2022) or host app, is getting popular nowadays(Ma, 2019a). More and more consumers are using them for shopping, payments, education and travel. Merchants develop brand-specific mini-apps to sell goods, such as Bubble Mart. The mini-apps have similar functions to Android apps, but are more convenient than Android apps. They rely on Web technologies but also integrate with capabilities of the native apps. The size of mini-apps is limited by the host platform, generally smaller than 20MB, and their Web-like structure makes them free from installation. According to the statistical agency Aladdin Institute’s article(ald, 2022) and Statista’s report(sta, 2022), the number of WeChat mini-apps has achieved 3.8 million, which is even more than the Android apps on Google Play (3.5 million).

However, the data leak issues in these mini-apps have been easily neglected. Mini-apps could access many kinds of personal information such as name and gender(Ma, 2019b). A report(nan, 2020) from the China Academy of Information and Communications found that among 52 commonly used mini-apps, 25$\%$ would share user data with third parties. Only 38.5$\%$ of mini-apps had a document describing information processing, which is often referred to as a privacy policy.

Regulations related to personal information protection explicitly prohibit this behavior. China’s latest mobile application personal information protection regulation(chi, 2020) requires mobile applications to be open and transparent. It asks mobile applications should clearly inform users how to obtain and use data. The EU General Data Protection Regulation(GDP, 2018) also states that data processing should meet ”lawfulness, fairness and transparency”.

Unfortunately, most mini-apps do not meet the above requirements. For example, Figure 1 shows a mini-app for sharing communication groups, called XiaoMaQun. On its share page, when the user clicks the ”Select Location” button, the ”searchLocation” function bound to the button is called. The user’s geographical location is obtained by ”wx.chooseLocation” and finally is transferred to an external server by ”wx.request”. However, this behavior is not mentioned in the document it provides to explain the collection of information. The act of obtaining user data without notification violates the consistency of behavior and description.

In the past, problems such as inconsistency and noncompliance have been studied in Android apps. For different analysis objects and targets, relevant research can be divided into two categories: program behavior analysis and privacy policy analysis. The goal of program behavior analysis is to search the acquisition and transmission of sensitive information. Some studies focus on data passing in functional code(Enck et al., 2014; Xue et al., 2018; Arzt et al., 2014; Octeau et al., 2013; Li et al., 2015; Gordon et al., 2015; Pan et al., 2018; Li et al., 2017), while others focus on data collection in user interface(Nan et al., 2015; Huang et al., 2015, 2016; Andow et al., 2017; He et al., 2020). Privacy policy analysis uses natural language processing technology, focusing on the description of data collection and use, generally combined with program analysis work to detect contradiction and noncompliance issues in apps(Yu et al., 2018; Slavin et al., 2016; Zimmeck et al., 2016; Andow et al., 2020; Bui et al., 2021; Jin et al., 2018; Wang et al., 2018; Fan et al., 2020).

Disappointingly, the traditional detection method in Android apps is difficult to perform in the mini-app scenario. There are two main challenges as follows:

Low availability of mini-app analytical tools. Most of the research in the past was carried out around the Android apps, lacking the analysis tool of the mini-apps. The first and most critical difference between them is the language difference. Mini-apps use the JavaScript language as their logic language. Compared with the strongly typed language Java of Android apps, the dynamic characteristics(Chugh et al., 2009; Hedin and Sabelfeld, 2012) of JavaScript bring many obstacles to behavior analysis, such as the scope-based execution and flexible variable types. Second, most of the tools around JavaScript is focused on vulnerability checking and lack available interface for taint analysis, such as SAFE(Park et al., 2017) and Understand(Und, 2022), which makes it difficult to migrate and expand on mini-apps. Finally, there are some platform’s predefined object and predefined APIs(e.g., asynchronous ”wx.chooseLocation” and the transfer function ”setData” in Figure 1). These characteristics can cause fractures in the data flow analysis results of traditional tools, such as TAJS(Jensen et al., 2011).

Coarse granularity of consistency detection methods. First, some past methods use rough data types in comparison, such as Polisis(Harkous et al., 2018) only used 5 advanced data types and PolicyCheck(Andow et al., 2020) only analyzed 12 data types supported by the data flow analysis tools AppCensus(App, 2022). Second, in terms of data operation analysis, some methods do not use data flow results to characterize behavior, which can lead to imprecision. For example, CHABADA(Gorla et al., 2014) only extracts the frequency of API usage, and Purliance(Bui et al., 2021) only extracts network traffic. Finally, in terms of the inconsistency patterns, in addition to the omitted disclosure and vague disclosure in Android apps(Andow et al., 2020), there is a new inconsistency in the mini-apps: the privacy policy will have serious redundant expressions that exceed the actual behavior. This issue has been ignored in previous studies.

In order to solve the above problems, we propose the following two methods:

Taint analysis method based on data entity dependency network. Aiming at the special language characteristics and engineering structure of mini-apps, we propose a taint analysis method based on data entity dependency network. We first parse the program code into an abstract syntax tree, then parse the code nodes associated with the data into entity units, establish entity dependencies according to the structure of the syntax tree, and finally perform taint analysis based on the relationship network.

Fine-grained consistency matching method based on data practice model. Aiming at the diverse data processing behaviors in mini-apps, we propose a data practice based comparison method. To achieve fine-grained behavior descriptions, data processing behaviors are split into combinations of data types and data operations. We first build two dictionaries of data types and operations. In addition, the APIs in the WeChat mini-app development manual are grouped into three types according to their functions. Program code behavior and privacy policy descriptions are transformed into data practice sets. Based on this model, we use five patterns (intersection, separation and three kinds of overlap) and two strengths (strong and weak) to study the inconsistency in mini-apps.

The main contributions of this work are:

• •

This work proposes a taint analysis method for the mini-app scenario for the first time. On a total of 620 data streams in 7 mini-apps, this method achieves an accuracy of 84.8$\%$ and can make up for 84.6$\%$ of the lack caused by asynchronous data flow and UI interaction events in existing tools.

• •

It is the first inconsistency analysis work carried out in the mini-app scenario. Experimental results show that that there are serious inconsistencies in 89.4$\%$ of the 2,998 mini-apps tested.

• •

We implements a consistency detection system for WeChat mini-apps. About 100,000 mini-apps are collected and 2,998 privacy policies are extracted. To facilitate further research, system codes and datasets are available(MCD, 2022).

2. Background

2.1. WeChat Mini-app

The first mini-app was released on the WeChat platform in 2017. Nowadays, WeChat has become the largest and most popular platform for mini-apps(ald, 2022). There are more than 3 million mini-apps on the WeChat platform, and 450 million daily active users. Therefore, we choose the WeChat mini-app as our research object.

There are two main differences between mini-apps and traditional Android apps. First, mini-apps are developed by using the JavaScript dynamic programming language while apps are developed by using the Java, which is a static programming language. Second, mini-apps can only be accessed and run on its host platform while apps are executed in virtual machine. For example, the WeChat mini-apps need to run on the WeChat platform, i.e., the WeChat app.

2.2. Privacy Policy

The privacy policy for applications is a legal document and software artifact to help users understand their information processing, such as what information and why the developers collect and use, how users can update, manage, export, and delete the information.

The description related to information processing in the privacy policy is usually a combination of processing subject, data type, behavior and purpose. As shown in Figure 1, the statement on the right includes subject (”We”), behavior (”ask you to provide”), data type (”mobile phone number, …”), and purpose (”ensure that you enjoy our full service”).

However, since the privacy policies are written in natural language without a uniform structure, it is difficult to directly obtain the four corresponding parts from the sentences. Furthermore, the data type or behavior that imply the same semantic meanings might be written using different words, such as the ”user contact” usually also refers to the user’s ”mobile phone number” .

2.3. Data Protection Regulations

In recent years, different regions have successively promulgated regulations related to data protection. China’s Personal Information Protection Law(Chi, 2022) was released in 2021. It requires that the processing of personal information should follow the principles of openness and transparency, i.e., disclosing the personal information processing rules, including the purpose, method and data scope. European GDPR(GDP, 2018) (General Data Protection Regulation) ART 5 mentions that the data processing should meet the requirements of ”lawfulness, fairness and transparency”. In addition, the privacy rights mentioned by CCPA(CCP, 2022) include ”the right to know about the personal information a business collects about them and how it is used and shared”. The above laws require that data processing should allow users to know and agree. When the documents provided by the application do not match the actual behavior of the application, the precondition of the right to know is denied.

Therefore, in this work we propose a consistent comparison method between the actual behavior and the description about data processing in the mini-app scenario. Through program analysis and description analysis, it can help users and developers to understand whether the program meets the transparency principles proposed by the regulations.

3. Approach

The overview architecture of our approach is illustrated in Figure 2, which contains four procedure: 1) In the preparation procedure we crawl a set of mini-apps and extract their program codes and privacy policies; 2) In the first identification procedure, we identify the data practice in the program code using static taint analysis method; 3) In the second identification procedure, we extract the sentence description as tuples from the privacy polices using natural language analysis method; 4) In the consistency comparison procedure, we compared the data practices of the two to check for inconsistencies.

3.1. Preparation

In the preparation stage, there are three steps, including the mini-app downloading, the extraction of program codes and the obtaining of privacy policies.

As for where to download the mini-apps, unlike the Google Play for the Android app users, there is no open market for the mini-app users. Therefore, to obtain a set of mini-apps, we first crawl a name list of mini-apps from several third-party websites which make recommendations. Note that these sites only provide the mini-apps’ name or QR code to enter the mini-apps, not the code package. Then, we expand the list based on the search results on the WeChat client. For example, when searching for ”Meituan Takeaway”, the list of search results will not only give the mini-app with the same name, but also the mini-apps with extended names, such as ”Meituan Order”, ”Meituan Smart Hardware” and ”Mimi Takeaway”.

After downloading the mini-app set, considering that their corresponding code packages are usually compressed, we use an open source unpacking tool called WxAppUnpacker(wxa, 2022) to obtain the source code. The source code contain a main entry file app.js, multiple page files, resource files, additional plugins and third-party library files. For each page, it contains a logic file in JavaScript format, layout file in WXML(WeXin Markup Language) format, style file in WXSS (WeXin Style Sheets) format and configuration file in Json format.

There are two main presentation modes of the privacy policies, one is attaching the text to the code statically, the other one is dynamic linking, which will only be displayed when the specified page is open. For the code attaching mode, we directly extract them from the static code by using a set of keywords such as ”privacy policy” and ”agreement”. For the dynamic linking mode, we design a UI testing tool to search the policy text. This tool runs on the WeChat client through the automated testing framework Airtest(Air, 2022). Specifically, when it enters an mini-app, it first clicks the index button at the bottom to switch pages, and then clicks the text related to the privacy policy within each page. In addition to this, it also tries to explore on some intermediate pages, such as login registration and settings pages.

3.2. Definition Of Data Practice

In this section, we first give the definition of data practice as below.

Definition 1 (Data practice).

Data practice is the behavior of data processing by the application. It is denoted as a tuple, (t,a), where t represents the data type, and a represents the operations of data processing.

For example, the data practices related to location in Figure 1 can be represented by (location, Collect) and (location, Send). To accurately describe data practices, we constrain the scope of data types and data operations as follows.

3.2.1. Data Type Categories

We rely on a national standard called GB/T 35273-2020(chi, 2020) for mobile applications data collection and divide the data types into 13 primary categories and 80 secondary categories, which are listed in Table 1. And each secondary category contains a set of phrases that present similar semantic meanings due to the language diversity. For example, the ”address” secondary category has the entities ”city” and ”township”, which denote the address information in different ways.

Specifically, to expand the phrases under each secondary category, we first extract all the phrases from the UI layout files and privacy policies of 100 popular mini-apps in different categories. Then, we leverage the KNN algorithm to perform a phrase clustering, where the similarity calculation is performed based on the Word2vec(Mikolov et al., 2013) algorithm. Finally, we manually check and revise the phrases set for each secondary category to ensure its accuracy.

3.2.2. Data Operation Categories

Data operations are grouped into three categories based on different processes of data processing, including Collect, Use, and Send. Here, Collect refers to acquiring data, Use refers to processing data within the program, and Send refers to sending data from the inside to the outside. Table 2 lists our constructed vocabulary for three operation categories and their corresponding set of operation words.

3.2.3. Data Practice Examples

Figure 3 illustrates three data practice examples of the same data type ”phone number” and the three different data operations. First, the users are required to enter the mobile phone number when registering and logging in, which constitutes a tuple of (phone number, Collect). Second, this number is read from the cache and displayed on a ”Number Protection” page, which constitutes a tuple of (phone number, Use). Finally, when the user fills in the recipient and sender information to submit an order, the number will be sent to the server, which constitutes a tuple of (phone number, Send).

3.3. Identification of Data Practice in Program Code

The identification of data practice in code relies on the static data flow analysis method, which is divided into two steps: identification of data type and identification of data operation.

3.3.1. Identification of Data Type

Data types will be specified according to different data sources:

• •

Platform-provided API. t is determined by the data content of the return value. For example, the data content returned by ”wx.chooseLocation” is geographic location information, so t = location.

• •

User Input. t is determined by the text of the input associated component. In Figure 3, the prompt text of the input component ”Please input phone number” contains the keyword ”phone number”, so t = phone number.

The first rule relies on the type division of the APIs, however, to the best of our knowledge, there is currently no research on the taint analysis of mini-apps for reference. Some related studies only focus on the usage of a specific API(Wang et al., 2022), which is incomplete for our work. In order to solve this problem, we carefully read the API list of the developer manual provided by the WeChat, and divided these APIs into different categories according to their return content. As listed in Table 3, there are 150 source APIs such as ”wx.getSystemInfo” that returns the system information and ”wx.chooseImage” that accesses albums.

The second rule requires extracting the information provided by the user interface from the layout file. The relevant components contain the event-triggering component and the form submission component. In the case of Figure 1, the semantics about the data type can be directly parsed according to the description text (e.g. ”Select location”) or the bind event function name (e.g. ”searchLocation”). This part is appended to the text properties of the related component.

However, we find that some related components have no text description themselves. To solve the problem, we utilize the work of UIPicker(Nan et al., 2015). Specifically, nodes in the layout file will be resolved into a tree of components according to their containment relationships. For the missing description component, it searches the associated node text from the bottom up, and each time a node is accessed, it will search that node and all the node’s sub-node text until the associated description is found.

3.3.2. Identification of Data Operation

For a data practice of a certain type t, its data operations o are specified according to the following rules:

• •

Collect. When there is a source of t-type data (calling the API provided by the platform or user input), the data practice can be represented by (t, Collect).

• •

Use. When the data flow of t-type data passes through a usage type sink API (e.g. ”wx.setStorageSync” for storage), the data practice can be represented by (t, Use).

• •

Send. When the data flow of t-type data passes through a transmission category sink API (e.g. ”wx.request” for sending a request), the data practice can be represented by (t, Send).

Among the above three operations, Send and Use depend on the type of sink API at the end of the data flow. To distinguish different endpoints, the APIs that accept data are divided into two categories: usage and transmission, which is shown in Table 4. The division between them depends on whether the data is sent outside in their official description.

3.3.3. Data Flow Analyze

The analysis of operation depends on the results of data flow analysis. We first parse program code into the dependency network on different code entities and then perform data flow analysis based on the network.

Definition 2 (Code entitiy).

Code entity is a general term for elements in code, including variables, functions, classes, and files, etc., and can be used to build program dependency graphs.

Here we choose the three entities most closely related to the data dependency graph as the analysis targets, including variables, files and functions. The dependency resolution procedures are shown in Algorithm 1 and 2.

(1) We use a NodeJs library called esprima to parse the mini-app code into an abstract syntax tree, and determine the target entities according to the node type through predefined rules. ”GenerateNewEntity” in Algorithm 1 is used to determine whether a node will generate an entity object, such as ”var a = 1” will generate a variable entity ”a”.

(2) According to the grammar rules of JavaScript and WeChat mini-app, some nodes may generate different code scopes that affect data dependency graph construction. We create corresponding scope objects and add the above entities to these objects, and connect these scopes in a chain to solve it. ”buildScopeChain” in Algorithm 1 will link the scopes with the containment relationship, and the child scope can access the objects under the parent scope.

(3) As the Algorithm 2 is shown,the nodes will be traversed in each scope and build dependencies for the aforementioned entities based on whether the nodes involve data transfer or not. Nodes that can generate a transfer relationship include assignment statements, function parameter transfer, return values, and ”setData” defined by the WeChat mini-app. For example, ”a.setData(b)” will assign ”b” to ”a.data”.

Taking Figure 4 as an example, the code on the left will first be parsed into the abstract syntax tree. First, the entire tree is traversed to find the node that generates the entity, including variable declaration statements (yellow nodes) on lines 2 and 10, function parameter on line 12, and anonymous functions declaration on lines 9 and 12 (blue nodes).

Then, as divided by the dotted line diagram on the tree, the code will be divided into three levels of scope. The division of scope is to determine the correct dependencies of variables. For example, the variable ”t” is defined in lines 2 and 12, and the variable ”t” is used in lines 5 and 13. Based on the scope division, ”t” in line 5 will form a dependency with ”t” in line 2, and t on line 13 will form a dependency with ”t” on line 12.

Finally, we look for nodes with transitive behavior and add ”Set” dependencies to them. In the example, the variable definitions in lines 2 and 10, the callback function parameters in line 12, the predefined function ”setData()” in line 13, and the assignment of properties of objects in lines 4, 13, and 17 are regarded as data transfer. Their dependencies are constructed as a connection of related entities.

After construction, data flow search is a reachable search process from the starting point to the end point on the network. A complete flow is shown by the red line in the Figure 4. The source API ”wx.chooseLocation” first returns location information to ”t” (line 12), ”t” has transitive dependencies through ”setData” and ”e” (line 10), and finally passes it to a sink API ”wx.request” through the ”this” keyword. This path constitutes the data practice of (location, Send).

3.4. Identification of Data Practice in Privacy Policy

We use the natural language processing method to determine the data practice in privacy policy. Considering that the types and operations in the statement are expressed in the form of entities and relationships, we determine the data practice according to the following rules:

• •

Data type. For the entities in the statement related to data processing, if there is an entity description similar (e.g. ”city”) to the data type we specified (e.g. ”address”), t is the corresponding type category.

• •

Data operation. For a t-type entity, if the predicate (e.g. ”provide”) of t is within the three data operation types defined and o is the data operation corresponding to the predicate, this data practice is represented by (t, o).

The entities are meaningful things in a sentence and the predicates describe the connections between entities. The identification is divided into two steps: sentence classification and tuple extraction.

3.4.1. Sentence Classification

A privacy policy generally includes data irrelevant sentences. There would be a lot of unrelated sentences in the extraction procedure. In order to precisely locate and extract the descriptive text, we first split the privacy policy into separate sentences, and then classify them into data related and data unrelated sentences. Specifically, we construct a dataset of different sentences. One paper participant and three trained students participated in the labeling of the dataset. By labeling 50 privacy policies, 2136 sentences related to data processing were marked.

After that, we leverage the bag-of-words model for sentence classification. Each sentence is converted into a 1547-dimensional vector (consistent with the vocabulary dimension), with each dimension indicating whether the sentence contains the word in the corresponding position, and fed into different trained classifiers. For example, when using ”mobile number”, ”bank account”, ”location” as the vocabulary, the privacy policy snippet in Figure 1 is transformed into a (1,1,0) vector. The models are trained using different classification algorithms, including MLP, CNN and LSTM. The detailed parameters and classification effects of different models will be introduced in the Section 4.

3.4.2. Tuple Extraction

After the sentence classification, we use word similarity calculation method to extract key information from the sentence. First the sentence is split into tuples of entities and relationships using a triple extraction tool LTP(Che et al., 2020), then we use data types vocabulary for entities and data operations vocabulary for relationships to extract similar words respectively.

For example, the sentence in Figure 1 will be parsed into four tuples including (we, ask, you), (you, provide, personal information such as …), (you, ensure, you enjoy our full service) and (you, enjoy, our full service). Then, entity words like ”personal information like …” and ”our full service” will be compared with type words, and relationship words like ”provide” and ”ensure” will be compared with operation words. Text similarity methods include overlap coefficient, cosine distance, Euclidean distance, and Dice coefficient. Words that meet the similarity threshold will be extracted. For example, the former (data type) will get ”mobile phone number”, ”ID number”, ”bank account number” and ”third-party account number”, and the latter (data operation) will be extracted to get ”provide”.

3.5. Consistency Comparison

After completing the analysis of data practices in the program code and the privacy policy, the process of consistency comparison can be regarded as a comparison between the two data practice sets.

As shown in Figure 5, the relationships of sets can be divided into five patterns: intersection, separation, and three types of overlap. Among the three types of overlap, we use ”Uninformed” to represent that some data practices appear in the program code but do not appear in the privacy policy, and use ”Redundant” to represent that some data practices appear in the privacy policy, but do not appear in the program code. The non-overlapping parts of the first four subgraphs are inconsistencies and the last one statisfies the consistency requirements.

Taking into account the different severities of inconsistencies, the comparison results are divided into weak inconsistencies and strong inconsistencies. Weak inconsistency occurs when a data type results on both sides but the data operations are different. Strong inconsistency occurs when the two results have a completely different data types.

In the example shown in Figure 6, we obtains the connection network between source and sink APIs through data flow analysis on program code, which is transformed into 7 data practice tuples, and extracts the associated statements through the statement classification method on privacy policy, which are transformed into 8 data practice tuples. The comparison results belong to the intersection class shown in Figure 5(a). Strong inconsistencies exist in ”location”, ”document” in the program code and ”ID number”, ”bank account”, ”third-party account” in the privacy policy. Weak inconsistency exists in the ”phone number” mentioned in both results, and the ”Send” behavior in the program code is not mentioned in the privacy policy.

4. Evaluation

4.1. Research Question

We conducted our experiments based on the following five questions.

RQ1: How accurate is our method in extracting data practice from the mini-app’s program code?

RQ2: What is the distribution of data practice in the mini-apps’ program codes?

RQ3: How accurate is our method in extracting data practice from the mini-app’s privacy policy?

RQ4: What is the distribution of data practice in the mini-app’s privacy policies?

RQ5: What is the inconsistencies distribution in mini-apps? How serious are these inconsistencies?

4.2. Exprimental Setup

Dataset. We first obtained a list of 12,000 mini-apps from third-party websites. As shown in Figure 7, the average downloads of different categories of mini-apps ranged from 508 to 14,711. Among them, the number of tool-type mini-apps is the largest, at 5,938, and the number of express, medical, government, and catering mini-programs is less than 100. Then we expand the search on the client-side based on this list. Since the code package obtained by crawling does not carry downloads and categories information, the distribution of the final data set is difficult to obtain. We finally crawled about 100,000 mini-apps code packages and extracted 2,998 mini-apps with privacy policies as our base data set. There were some privacy polices we didn’t find, because for dynamically attached privacy policies, the testing tool cannot guarantee full access to them.

Metrics. We use classical accuracy and callback rates as the main evaluation metrics. Accuracy refers to the proportion of correct results in all samples, and this value is used to measure whether the method can give correct results. Recall rate refers to the proportion of all true values in the correct results, which is used to measure omissions in results.

Environment. We accomplished experiments on a server with three Intel Xeon Gold 6266C CPU, one NIVDIA GeForce RTX 3090 GPU and one 15TB hard disk. The operating system version is Ubuntu 18.04.

4.3. Accuracy of Taint Analysis Method

Since there is no relevant benchmark, we manually marked 7 randomly selected samples as shown in Table 5. We first divided data flows into three categories according to their sources: APIs called synchronously, APIs called asynchronously, and user interface inputs.

Specifically, taking Figure 1 as an example, ”setData” in line 6 is a synchronous API, and the statement in this line will be executed immediately in the body of the function declared in line 5. The ”wx.chooseLocation” in line 11 is an asynchronous API. After the user selects the location successfully, the location data will be passed to the parameters of the callback function. The ”searchLocation” in line 2 is a user-triggered event, and the event is an anonymous function in line 2. If it is an input type component, the data entered by the user will be passed to the parameter list of the anonymous function after the event is triggered.

The difference between mini-apps and traditional JavaScript taint analysis lies in the latter two types of data flow. For some JavaScript static analysis tools such as TAJS(Jensen et al., 2011), the data flow caused by the synchronous API can be analyzed given the function name of the data source. However, the asynchronous API customized by the WeChat platform and the data transfer caused by the unique UI trigger events cannot be obtained. As shown in Table 5, the data streams of three parts are 95, 328 and 197 respectively, accounting for 15.3$\%$, 52.9$\%$ and 31.7$\%$. It can be seen that the data flow analysis method that does not adapt to the mini-apps will lose 84.6$\%$ of the data flow analysis results.

During testing we also found that there were some broken data flows. Of the 620 calibrated data streams, 524 are expected, 94 are broken and no result is wrong. The main reason for the fracture is that we can’t solve the built-in objects provided by JavaScript very well. For example, in ”a.push(b)”, when ”a” is an array type, ”push” will construct a data dependency for ”b” and ”a”. A simple solution is to fix the built-in property list. However, ”a” may also be a custom object and ”push” is a custom function and does not transfer data. We need to know the exact variable type, but this is very difficult for dynamically typed languages.

Answer to RQ1: The data flow analysis method we propose makes up for the loss of 84.6$\%$ of other existing analysis tools in the mini-app scenario, and 84.8$\%$ of all results are in line with expectations. This method can effectively analyze the data processing behavior from the mini-app code.

4.4. Data Practice Distribution in Program Code

The analysis result on 2,998 mini-apps’ codes are shown in Figure 8. Figure 8(a) and Figure 8(b) are the distributions of different independent source and sink APIs. The results were transformed into the form of data practice attributes which is shown in Figure 8(c) and Figure 8(d). Finally, we selected the top 20 data types and drew the distribution heat map of data practices, as shown in Figure 8(e). Through statistics, we have the following findings:

(1)The most frequently used sources come from the API interface provided by the WeChat platform. In Figure 8(a), more than 2,000 mini-apps use ”wx.request” for sending requests and ”wx.login” for user login.

(2) Some custom event functions that get specific types of data are also very common. For example, more than 700 mini-apps customize ”getPhoneNumber” to obtain the user’s mobile phone number and ”formSubmit” to submit form information. Developers have a common habit of naming functions.

(3) The three operations are very common in mini-apps. Figure 8(d) also shows that 2,996(99.93$\%$) mini-apps will collect, 2,757(91.96$\%$) will use and 1,728(57.64$\%$) will send user data. The proportion of usage behavior and collection behavior is close and the transmission behavior is more than half.

(4) The collection of user sensitive information is widespread. Figure 8(e) shows that the most data practices focus on the communication data, such as request return (95.7$\%$) and login credentials (40.5$\%$). However, there are still more than 1,161 (38.73$\%$) mini-apps that collect users’ sensitive location information and photo albums.

Answer to RQ2: For data types, mini-apps tend to collect communication data (e.g. request returns (95.7$\%$) and login credentials (40.5$\%$)), as well as user sensitive information (e.g. location (61.2$\%$) and album(52.2$\%$)). For data operations, most of the data will be used within the mini-apps and external transmission is also very common in mini-apps. The three data operations collect, use and send account for 99.93$\%$, 91.96$\%$ and 57.64$\%$ respectively.

4.5. Accuracy of Description Extraction Method

4.5.1. Classifier Evaluation

We used different vector transformation methods and different classification models to find the best classification method. First, we picked 50 privacy policies, completed the annotation of sentences, and divided them into relevant sentences and irrelevant sentences. There were 2,136 sentences divided into related sentences. Then, we used a bag-of-words model to convert sentences into different vectors for different vocabularies. Finally, we input these vectors into the model to complete training and testing.

As shown in Table 6, there are three vocabularies in the transform. ”Type” means the original data type vocabulary, ”Type$\&$Operation” means adding an operation vocabulary to the type vocabulary, ”Type*Operation” means combining the type word and operation word into a bigram, and then forming a new vocabulary. Three models includes MLP, CNN and LSTM. In terms of parameter settings, MLP uses a 512-dimensional dense layer, CNN uses a three-layer convolutional network layer with dimensions of 256, 128 and 64, and LSTM uses a 256-dimensional lstm layer.

Table 6 shows that when using the merged vocabulary and the MLP model, the classification of sentences is the best, with an accuracy of 97.98$\%$ and a recall rate of 92.56$\%$. We think there are two reasons:

(1) In terms of vocabulary selection, the target sentence usually contains data type related word and operator, but not always both. The extended vocabulary can extract more information from the sentence, but the premise of the extension is that the newly added words have a wide distribution in the sentence.

(2) In terms of model selection, the CNN model is generally used for image recognition and do not perform well for one-dimensional data, and the LSTM model requires more time-series features to be extracted from sentences. The aforementioned vector transformation methods cannot work well with these models.

4.5.2. Tuple Extraction Evaluation

Here we discuss the effects of four similarity extraction methods. First, we randomly selected 306 relevant sentences from 2,136 and completed the annotation of data practice. Then, we used the LTP tool to extract the entities and relationships in the sentences, calculated the word similarity to extract the data practice, and adjusted the similarity threshold to find the best extraction method.

Figure 9 shows the best method is the overlap coefficient when the similarity threshold is 1 with an accuracy rate of 97.5$\%$. But before the 0.5 threshold, this effect is not as good as Euclidean distance and cosine distance using vector space for similarity calculation.

We think the reason is related to language expression habits. Words related to data processing tend to be specific and distinct. Such words do not undergo much change when they are used, usually only adding some modified words, which will not affect the original form of the words. For example, ”city” falls under the ”address”, and the privacy policy would specify the scope with ”currently living city” or ”working city”, these modifiers do not change the word ”city”. This means that once the word ”city” is matched, we can assume that it describes an address-related data with a high probability. Therefore, overlap coefficient that is more inclined to include matching method perform best. However, with a low similarity threshold, this matching method introduces many erroneous results. For example, ”mobile phone number” and ”ID number” are grouped together because they both have the word ”number”.

Answer to RQ3: On 2136 calibrated sentences, the accuracy rate of sentence classification model is 97.98$\%$ , and the callback rate is 92.56$\%$. On 306 more finely calibrated sentences, the extraction method has an accuracy of 97.5$\%$. The method can effectively classify sentences and extract data-processing-related descriptions.

4.6. Data Practice Distribution in Privacy Policy

We extracted data practices from 2,998 privacy policies. Among the results, 1,272 (42.43$\%$) did not contain relevant descriptions of data processing, and 1,746 (58.24$\%$) privacy policies included at least one data practice. Their distribution is shown in Figure 10. Through statistics, we have the following findings:

(1) The data types stated in the privacy policy are wide-ranging, and most of them are user-sensitive information. As shown in Figure LABEL:fig:policydistribution-a, privacy policies favor data practices that state an individual’s name, address, and mobile phone number. The difference from the code-side analysis results is that the privacy policy seldom states communication-related information, such as login credentials.

(2) The privacy policy states far less about collecting and sending than collecting. For the data operations shown in Figure LABEL:fig:policydistribution-b, there are only 841 privacy polices that mention sending data and 327 privacy polices that mention collecting data, accounting for 48.17$\%$ and 18.73$\%$.

(3) The lack of privacy policy description is serious. On the one hand, only about half (58.24$\%$) of the privacy policies contain at least one data practice. On the other hand, as shown in Figure 10(c), among the 1,746 privacy policies with data practices, the number of data practices with the most declarations (personal name, Use) is only 647.

Answer to RQ4: Privacy policies tend to declare user sensitive information such as personal name (27.8$\%$), address (22.3$\%$), and phone number(21.5$\%$). They rarely declare the collection and sending of data. The percentages of collecting, using and sending statements are 28.1$\%$, 50.1$\%$ and 10.9$\%$. Half of the privacy policies do not mention data practices, and the number of most mentioned data practices (personal name, Use) is 647.

4.7. Inconsistency Distribution

We performed consistency analysis on 2998 mini-apps and take three sets including data practices, data types and data operations to analyze the five patterns referred in Figure 5. Figure 11(a) shows the distribution of five patterns. Figure 11(b)-11(e) shows the top 10 data practices’ heat maps for strong and weak inconsistencies. Through statistics, we have the following findings:

(1) The inconsistency in the mini-apps is very serious. Figure 11(a) shows that this inconsistency is mainly manifested in the separation of program code and privacy policy. The number of this most pattern is 2293, accounting for 76.5$\%$. For all four inconsistent patterns, the sum is as high as 2680, accounting for 89.4$\%$.

(2) These inconsistencies are mainly caused by inconsistent data types. Figure 11(a) shows that the pattern distributions of data types and data practices basically coincide.

(3) These inconsistencies are mainly caused by the data practice of the program code exceeding the privacy policy. As shown in Figure 11(b)-11(e), inconsistencies are mainly distributed as strong uninformed inconsistencies. The largest uninformed data practice (request return, Collect) appear in 1,980 mini-apps, and the largest redundant data practice (account, Use) only appear in 589 mini-apps. The numbers of weakly inconsistent data practices are all less than 100.

Answer to RQ5 Among the 2998 mini-apps tested, there are 2,680 inconsistent mini-apps, accounting for 89.4$\%$. The inconsistency in mini-apps is extremely serious and is mainly caused by the data practice on the code side.

5. Cases and Suggestions

5.1. Cases

We randomly selected 6 real-world samples and their detailed results are shown in Table 7. Through sample analysis, we believe that the reasons for the inconsistencies are as follows:

Missing description and rough category. For case 1, its privacy policy simply summarizes user data as ”registration data”, and does not specifically describe how each data is acquired and used, which makes it impossible for the classifier to recognize it as a statement related to data processing. The privacy policy of case 2 mentions the collection of ”express” data, however, the scope of ”express” data is very broad and may include the location and mobile phone number. In fact, its privacy policy doesn’t go any further to explain what part of the data is collected.

Homogenized template and omitted characteristics. Data practices in program code are hardly covered perfectly in the privacy policy. The complete mismatch in case 3 (the intersection between program code and privacy policy is empty) indicates that its privacy policy is absolutely separate from the actual mini-app behavior. Upon inspection, we find that its privacy policy uses a web-popular template, but omits the description of its own characteristics.

Copied document and less adjustment. Some mini-apps have many data practices descriptions in their privacy polices, and their redundancy is very high. For example, the privacy policy of case 5 mentions 12 data practices but there are only 8 data practices in its program code. Further, we found that its privacy policy is very similar to that of the Android application with the same name. However, this mini-app has only a fraction of the functions of an Android application with the same name, which causes the description to exceed the actual behavior.

In our opinions, these phenomena are closely related to the characteristics and ecology of mini-apps:

(1) Mini-apps are small in size and low in development cost, which attracts many individual developers. They do not have professional knowledge of privacy policy writing, and the description documents are often written very briefly and irregularly. This problem is also common in Android apps(Sunyaev et al., 2015; Story et al., 2019; Zimmeck et al., 2019). Not enough experience results in the absence of a description of data processing in the privacy policy.

(2) There are also many mini-apps migrated from Android apps. They have partial functionality, but carry the full privacy policy on the Android side. The developers ignored the changes in the migration process, resulting in a lot of redundancy in the privacy policy.

5.2. Suggestions

Therefore, based on the above discussion, to improve such problems, we propose the following suggestions:

Developer: Reduce the collection of irrelevant information and the straightforward use of templates. Many mini-apps collect information that is not relevant to their functionality. For example, the function of case 3 is to issue a mechanical use application. There is no need to obtain the user’s location information and its privacy policy also does not mention this. Therefore, reducing the collection of unnecessary information can reduce the risk of non-disclosure, and make the content of the privacy policy more concise. Case 6 is a mini-app that just displays text. It does not collect any data, and its privacy policy does not need to mention data processing-related content, so it meets the consistency requirement. In addition, it is recommended that developers learn the standard privacy policy requirements, reduce the direct use of templates, and provide tailor-made privacy policies for their own mini-apps.

Platform: Provide data flow detection tools and privacy policy writing support. For the platform, verifying whether the code contains data processing behaviors and feeding back the results to the developers can effectively help them reduce omissions in writing privacy policies(Balebako et al., 2014). Additionally, the submission of a privacy policy should be required. The platform can provide writing support and use the aforementioned analysis results to help developers improve their privacy policies.

6. Threats to Validity

Tool independence. We use many open source tools to build such a consistency analysis system, but we do not conduct a detailed evaluation of the performance of these tools. If the results given by these tools are not complete, that may further affect the system’s accuracy.

Migration to other platforms. At present, many Android application platforms have the function of mini-apps. We briefly surveyed the popular mini-app platforms, including Alipay(Ali, 2022), Baidu(Bai, 2022) and Bytedance(Byt, 2022). They all use javascript as the core logic language, and a framework structure using layout files (xml-like format), style files (css-like format) and configuration files (json format). However, they use differentiated API lists and extended functionality, which can cause migration difficulties. For example, the APIs of the Alipay mini-app use my as the main object name (WeChat mini-apps use wx) and the Baidu provides many AI model calling interfaces in its API list.

Migration to other regulation requirements. This consistency detection system mainly only verifies the user’s right to know in laws and regulations. But there are also other compliance requirements, such as completeness(Tesfay et al., 2018; Rahman et al., 2022). It is necessary to classify and subclause privacy policies in more detail to detect whether they meet these requirements.

7. Related Work

7.1. Mini-app Related Research

Mini-apps are an emerging application form, and there are only a few related researches, which can be divided into vulnerabilities, testing and statistics. Lu et al.(Lu et al., 2020) reveal new security vulnerabilities in the new mini-app ecosystem by analyzing system resource exposure, sub-window deception, and sub-program hijacking. These vulnerabilities could allow an attacker to escalate privileges or access resources. At the same time, they evaluat the proposed attack on 11 popular mini-app platforms, revealing the prevalence of the security vulnerability. Liu et al.(Liu et al., 2020) design WeJalangi, a dynamic analysis tool for WeChat mini-apps, which can effectively mine mini-app code defects. MiniCrawler(Zhang et al., 2021) injects and modifies the mini-app host platform application through the plug-in and filters and parses the field information returned by the download to obtain the link. They make measurements on the code ecology based on the crawled datasets, such as API usage and obfuscation rate. Wang et al.(Wang et al., 2022) summarized the main reasons for common bugs in WeChat mini-apps, and developed WeDetector to detect these bugs.

The above research does not focus on the analysis of the privacy in mini-apps. Also unfortunately, due to the security restrictions of the host app, some tools are no longer available (e.g. the interface used by MiniCrawler is invalid due to WeChat forced version updates, and WeJalangi is closed source).

7.2. JavaScript Taint Analysis

Unlike Android app, which uses Java, the mini-app adopts a web-like architecture and uses JavaScript as the core language. However, JavaScript’s dynamic characteristics have brought many difficulties to language parsing. TAJS(Jensen et al., 2011) is a classic work in JavaScript data flow analysis. It proposes an extending static analysis model for HTML DOM and browsers API, and applies it to Web applications. JSAI(Kashyap et al., 2014) is a set of methods for converting JavaScript into an intermediate language (IR), providing definitions of precise and abstract semantics and unite them to give a configurable analysis. SAFE(Park et al., 2017) is an parser that supports JavaScript abstract syntax tree rewriting and control flow graph analysis. JsPrime(Nishant Das Patnaik, 2022) is a taint analysis tool for XSS attacks, uses the source and sink taint API lists in popular JavaScript libraries, and supports variable and function tracking. CodeQL(Cod, 2022) is a code audit tool launched by Github. It first parses the code into a query database and then allows users to customize the query format. CodeQL also provides the taint analysis function for JavaScript. JsFlow(Hedin et al., 2014) performs information flow track and inspection through dynamic analysis. Understand(Und, 2022) is a code visualization tool which supports code dependency analysis and control flow graph analysis.

We compared the adaptability of the above analysis frameworks on mini-apps, as shown in Table 8. The above work has been well adapted to some scenarios of JavaScript (e.g. Web for browsers and Node for servers), but it is still hard to achieve accurate analysis on mini-apps. As shown in the table, some tools provide limited interfaces and do not support taint analysis because these tools are designed for type checking rather than taint tracking. In addition, there are many asynchronous APIs and a new UI interaction mechanism which will affect the data flow analysis.

7.3. Compliance Analysis on Android Apps

Mobile applications’ privacy and security issues are a common topic, and many laws and regulations promulgated have placed restrictions on data processing. However, the behavior of the software is usually imperceptible to the user, and the correctness of the documents provided by the software, like privacy policies, can hardly be verified(Yu et al., 2016). The consistency problem is to use program analysis methods to obtain how the program collects and uses user data information, and compares this result with the description text to check whether there are any violations or omissions.

Behavior analysis. According to different analysis objects, behavior analysis can be divided into analysis based on tainted data flow and analysis based on user interface. The analysis based on tainted data flow obtains the data dependencies in the program code through static or dynamic methods, and discovers the behavior of the program when processing data. The target of this type of work is to study accurate data flow search methods under a specific code environment or architecture. The related work includes Flowdroid(Arzt et al., 2014), IccTA(Li et al., 2015),TaintDroid(Enck et al., 2014), DroidSafe(Gordon et al., 2015) and Amandroid(Wei et al., 2018). The analysis based on the user interface provides additional explanatory support for data breaches by extracting textual information on the UI, such as determining the type of user input data. The related work includes UIPicker(Nan et al., 2015), Uiref(Andow et al., 2017), Bidtext(Huang et al., 2016) and IconIntent(Xiao et al., 2019).

These studies provide ideological guidance for the behavior analysis of mini-apps. However, they cannot provide sufficient tool support because mini-apps and apps employ two completely different programming languages (Javascript and Java). In addition, in the process of layout resource resolution, the Web-like structure in mini-app is also different from that of Android.

Description analysis. CHABADA(Gorla et al., 2014) is an early research to detect the difference between APP behavior and description. It clusters the keywords that appear in different types of applications, counts the frequency of different APIs, and uses a classifier to detect anomalies. Autocog(Qu et al., 2014) expands the permission set of existing research and uses learning methods to improve the correlation accuracy of behavior matching. AsDroid(Huang et al., 2014) uses static program analysis and interface text to detect conflicts. Polisis(Harkous et al., 2018) proposes an automated framework based on deep learning to achieve query and question answering of privacy description documents. PPChecker(Yu et al., 2018) proposes a privacy policy evaluation method that evaluates privacy policies around completeness, correctness, consistency, and user-friendliness. PoliCheck(Andow et al., 2020) combines AppCensus(App, 2022) to obtain data streams, uses PolicyLint(Andow et al., 2019) to parse privacy policy documents, and finally builds a flow-to-policy model to detect consistency. Purliance(Bui et al., 2021) complements the purpose analysis of the data usage section, using network traffic to represent the specific behavior of the purpose.

Some of the above studies have coarse granularity in the extraction of program behavior, and only extract simple program behavior elements such as API usage frequency in CHABADA(Gorla et al., 2014) or traffic in Purliance(Bui et al., 2021). In addition, the scope of data types and data operations for some comparison work is limited. For example, PolicyCheck(Andow et al., 2020) only analyzed 12 data types supported by the data flow analysis tools AppCensus(App, 2022).

8. Conclusion

This paper proposes a mini-apps consistency analysis framework for the first time. The system contains four procedures: preparation, identification of data practice in program code and privacy policy, and consistency comparison. We crawl 100,000 mini-apps on WeChat client in the wild and extract 2,998 with a privacy policy. Among them, only 318 meet the consistency requirements, 2,680 are inconsistent, and the proportion of inconsistencies is as high as 89.4$\%$. Based on the above results and 6 anlyzed real-world cases, we think the reasons for the inconsistencies mainly caused by mini-apps’ characteristics and ecology. Developers are suggested to reduce the collection of irrelevant information and the straightforward use of templates, and the platform is suggested to provide data flow detection tools and privacy policy writing support.