Privacy policy generation method, electronic equipment and computer readable storage medium

Abstract

The embodiment of the invention discloses a privacy policy generation method, electronic equipment and a computer readable storage medium, and belongs to the technical field of terminal privacy security. The privacy policy generation method comprises the steps of performing sensitive behavior scanning on a component object, and recording a target program interface which scans sensitive behaviors; performing sensitive behavior identification on the target program interface based on a preset sensitive behavior set, and recording an identification result; determining a privacy policy statement corresponding to the sensitive behavior in a preset sensitive behavior set according to the identification result; and assembling the privacy policy statements according to a preset rule to generate a privacy policy text. According to the embodiment of the invention, the sensitive interface and the sensitive behavior in the component object can be completely identified without leaving behind, and the privacy security degree of a product and the security experience of a user are improved.

Description

Technical Field

[0001] This application relates to the field of terminal privacy and security technology, and in particular to a method for generating privacy policies, electronic devices, and computer-readable storage media. Background Technology

[0002] As mobile smart devices become increasingly integrated into all aspects of our work and lives, privacy protection is receiving more and more attention from users. Currently, due to compliance requirements, most applications will display a privacy policy upon first launch, clearly showing users the permissions the application needs to request and the sensitive data that needs to be accessed, saved, or transmitted.

[0003] However, many applications of these technologies involve issues such as unauthorized collection of personal information, incomplete disclosure of privacy policies, and excessive requests for permissions. Therefore, it is necessary to comprehensively identify potential sensitive behaviors in products in order to effectively ensure user privacy and security. Summary of the Invention

[0004] The main objective of this application is to provide a method for generating a privacy policy, an electronic device, and a computer-readable storage medium, which aims to at least solve the technical problem of how to comprehensively identify potentially sensitive behaviors in a product.

[0005] To achieve the above objectives, this application provides a method for generating a privacy policy, the method comprising:

[0006] Perform sensitive behavior scanning on component objects and record the target program interfaces where sensitive behaviors are detected;

[0007] Sensitive behaviors of the target program interface are identified based on a preset set of sensitive behaviors, and the identification results are recorded.

[0008] Based on the identification results, determine the privacy policy statement corresponding to the sensitive behavior from the preset set of sensitive behaviors;

[0009] The privacy policy statements are assembled according to preset rules to generate the privacy policy text.

[0010] In addition, to achieve the above objectives, this application also provides an electronic device, which includes: a memory, a processor, and a computer program stored in the memory and executable on the processor. When the computer program is executed by the processor, it implements the privacy policy generation method described above.

[0011] In addition, to achieve the above objectives, embodiments of this application also provide a computer-readable storage medium storing a computer program, which, when executed by a processor, implements the privacy policy generation method described above.

[0012] This application proposes a privacy policy generation method, an electronic device, and a computer-readable storage medium. In the privacy policy generation method, a component object is first scanned to record the target program interfaces containing sensitive behaviors. Then, based on a preset set of sensitive behaviors, the target program interfaces are identified for sensitive behaviors, and the identification results are recorded. This allows the user to determine which specific sensitive behavior within the preset set the scanned sensitive behavior belongs to. Next, based on the identification results, a privacy policy statement corresponding to the sensitive behavior is determined from the preset set. Finally, the privacy policy statement is assembled according to preset rules to generate the privacy policy text. The privacy policy generation method provided by this application can completely and without omission identify sensitive program interfaces and sensitive behaviors in a component object. Furthermore, the mapping from sensitive program interfaces to sensitive behaviors and corresponding privacy policy statements enables compliance self-checking and gap filling in the privacy policy, improving the product's privacy security level and user security experience, and expanding the product's market competitiveness. Attached Figure Description

[0013] To more clearly illustrate the technical solutions in the embodiments of this application or related technologies, the drawings used in the description of the embodiments or related technologies will be briefly introduced below. Obviously, the drawings described below are only a part of the embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0014] Figure 1 A flowchart illustrating a privacy policy generation method provided in this application embodiment;

[0015] Figure 2 A detailed flowchart illustrating some steps of a privacy policy generation method provided in this application embodiment;

[0016] Figure 3 A further detailed flowchart illustrating some steps of a privacy policy generation method provided in this application embodiment;

[0017] Figure 4 A schematic diagram of a privacy policy generation device provided in this application embodiment;

[0018] Figure 5 A schematic diagram of the structure of a newly added module in a privacy policy generation apparatus provided in this application embodiment;

[0019] Figure 6 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Detailed Implementation

[0020] In the following description, specific details such as particular system architectures and techniques are set forth for illustrative purposes and not for limitation, in order to provide a thorough understanding of the embodiments of this application. However, those skilled in the art will understand that the embodiments of this application can also be implemented in other embodiments without these specific details. In other instances, detailed descriptions of well-known systems, apparatuses, circuits, and methods are omitted so as not to obscure the description of the embodiments of this application with unnecessary detail.

[0021] It should be noted that although a logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than that shown in the flowchart. The terms "first," "second," etc., in the specification, claims, and the aforementioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence.

[0022] It should also be understood that references to "one embodiment" or "some embodiments" in the specification of embodiments of this application mean that one or more embodiments of this application include a specific feature, structure, or characteristic described in connection with that embodiment. Therefore, the phrases "in one embodiment," "in some embodiments," "in other embodiments," "in still other embodiments," etc., appearing in different parts of this specification do not necessarily refer to the same embodiment, but rather mean "one or more, but not all, embodiments," unless otherwise specifically emphasized. The terms "comprising," "including," "having," and variations thereof mean "including but not limited to," unless otherwise specifically emphasized.

[0023] As mobile smart devices become increasingly integrated into all aspects of our work and lives, privacy protection is receiving more and more attention from users. Currently, due to compliance requirements, most applications will display a privacy policy upon first launch, clearly showing users the permissions the application needs to request and the sensitive data that needs to be accessed, saved, or transmitted.

[0024] However, many applications of these technologies involve issues such as unauthorized collection of personal information, incomplete privacy policies, and excessive requests for permissions. Generally, the content of a privacy policy is closely related to the functions implemented within the application. For example, if an application initiates location services and calls location-related APIs, then the privacy policy must explicitly state that the application will perform location services and read location information. Therefore, a comprehensive identification of potentially sensitive behaviors within a product is necessary to effectively ensure user privacy and security.

[0025] Based on this, embodiments of this application provide a privacy policy generation method, apparatus, device, and computer-readable storage medium. In the privacy policy generation method, a component object is first scanned to record target program interfaces exhibiting sensitive behaviors. Then, based on a preset set of sensitive behaviors, the target program interfaces are identified for sensitive behaviors, and the identification results are recorded. This allows it to determine which specific sensitive behavior within the preset set the scanned sensitive behavior belongs to. Next, based on the identification results, a privacy policy statement corresponding to the sensitive behavior is determined from the preset set. Finally, the privacy policy statement is assembled according to preset rules to generate the privacy policy text. The privacy policy generation method provided by this application can completely and without omission identify sensitive program interfaces and sensitive behaviors in a component object. Furthermore, the mapping from sensitive program interfaces to sensitive behaviors and corresponding privacy policy statements enables compliance self-checking and gap filling in privacy policies, improving product privacy security and user security experience, and expanding the product's market competitiveness.

[0026] The privacy policy generation method, apparatus, device, and computer-readable storage medium provided in this application are specifically described through the following embodiments. First, the privacy policy generation method in this application embodiment is described.

[0027] Reference Figure 1 , Figure 1 This is a flowchart illustrating a privacy policy generation method provided in an embodiment of this application. This privacy policy generation method can be applied to a privacy policy generation device, such as... Figure 1 As shown, the privacy policy generation method provided in this embodiment includes steps S10 to S40.

[0028] Step S10: Perform sensitive behavior scanning on the component object and record the target program interface where sensitive behavior is detected;

[0029] In this embodiment, the component object includes, but is not limited to: executable files of applications and / or SDKs (Software Development Kits), source code and configuration files of applications and / or SDKs, and intermediate files generated during the compilation process of applications and / or SDKs. The purpose of performing sensitive behavior scanning is to identify the target program interfaces involving sensitive behaviors in the aforementioned component object. Specific sensitive behavior scanning methods include, but are not limited to, static scanning and dynamic scanning. For static scanning, since it covers all code paths of the scanned object, it can obtain more comprehensive scanning results. It can also be automated, has high efficiency and scalability, and can be analyzed before the scanned object runs, making it more accurate. Therefore, it can be used as a preferred scanning method. For dynamic scanning, it analyzes the scanned object during runtime. Its comprehensiveness and accuracy are relatively lower than those of static scanning, and it can be used as an alternative method.

[0030] It should be noted that in this embodiment, sensitive behavior scanning can scan for a variety of possible sensitive behaviors. Therefore, after a certain sensitive behavior is scanned, the name of the sensitive behavior is not directly known. Instead, the target program interface of the scanned sensitive behavior is recorded first. Then, the target program interface is identified through subsequent steps, so that the specific sensitive behavior can be accurately identified.

[0031] As an example, the implementation of a sensitive behavior may involve calls to multiple program interfaces. Therefore, the target program interface can be a specific program interface or a collection of multiple program interfaces related to the sensitive behavior.

[0032] Step S20: Identify sensitive behaviors of the target program interface based on a preset set of sensitive behaviors, and record the identification results;

[0033] In this embodiment, the preset sensitive behavior set includes at least various designated sensitive behaviors and designated program interfaces that have corresponding relationships. Therefore, if the target program interface is known based on the aforementioned steps, the specific designated sensitive behavior involved in the target program interface can be known by querying the designated program interface that is consistent with the target program interface in the preset sensitive behavior set. Therefore, the identification result in this embodiment can be the designated program interface or the designated sensitive behavior in the preset sensitive behavior set.

[0034] Step S30: Based on the identification results, determine the privacy policy statement corresponding to the sensitive behavior from the preset sensitive behavior set;

[0035] In this embodiment, the preset sensitive behavior set may also include specified templated text corresponding to the specified sensitive behavior or specified program interface; when the identification result is the specified program interface or specified sensitive behavior in the preset sensitive behavior set, the specified templated text corresponding to the specified sensitive behavior or specified program interface can be mapped from the preset sensitive behavior set according to the identification result, and used as the privacy policy statement corresponding to the scanned sensitive behavior.

[0036] Step S40: Assemble the privacy policy statement according to preset rules to generate the privacy policy text.

[0037] In this embodiment, the preset rule can be a specific way of instantiating the privacy policy statement. When the privacy policy statement is a specified templated text, the instantiation method will vary depending on the templated method. The final generated privacy policy text can be used to disclose to users what sensitive behaviors the scanned component objects involve.

[0038] As an example, if the privacy policy statement is "Application A needs to access data C when performing function B", the default rule can be to fill in A, B, and C to complete the instantiation. Then the generated privacy policy text after assembly can be "The WeChat application needs to access location information data when performing the location sharing function".

[0039] This embodiment provides a method for generating a privacy policy that can completely and without omission identify the sensitive program interfaces involved in sensitive behaviors in an application. Even if the SDK is a black box to the application developer, it can still identify the sensitive program interfaces and sensitive behaviors it contains. In addition, the mapping from sensitive program interfaces to sensitive behaviors and corresponding privacy policy statements can realize compliance self-checks and fill gaps in privacy policies, improve the privacy and security level of electronic devices using this method and the user's security experience, and expand market competitiveness.

[0040] In some feasible embodiments, prior to step S20 above, the privacy policy generation method may further include:

[0041] Step S11: Persist the specified sensitive behaviors that need to be disclosed in the privacy policy to obtain a preset set of sensitive behaviors; wherein, the preset set of sensitive behaviors includes corresponding specified sensitive behaviors, specified program interfaces and specified templated text.

[0042] It is understandable that the premise of performing sensitive behavior identification is that a set of preset sensitive behaviors is set up in advance as a data warehouse. In this embodiment, persistence is a mechanism for converting program data between persistent and transient states. In layman's terms, it is to persist transient data (such as data in memory, which cannot be permanently saved) into persistent data (such as persisting to a database, which can be stored for a long time). The correspondence between the specified sensitive behavior, the specified program interface, and the specified templated text is not limited in quantity. This is because the implementation of a sensitive behavior may involve the call of multiple program interfaces. In other words, the specified program interface is not limited to a specific program interface, but can be a collection of multiple program interfaces.

[0043] As an example, the specified sensitive behaviors that need to be disclosed in a privacy policy can include all behaviors involving sensitive user information performed by the application during the execution of its functions under the supervision of regulatory authorities. It can also include behaviors that are not under the supervision of regulatory authorities but are within the scope of industry common knowledge. Such specified sensitive behaviors include, but are not limited to: reading SMS / MMS messages; writing SMS / MMS messages; initiating location services; reading location information; reading user's local data, such as multimedia data, files, and information about applications installed on the local device; and recording audio in the background.

[0044] In some feasible embodiments, the specified program interface may include all program interfaces that need to be invoked in order to implement the specified sensitive behavior.

[0045] In this embodiment, the specified program interface (program interface set) corresponding to each specified sensitive behavior includes all program interfaces implemented and called by the application in the operating system in which the application runs in order to implement the specified sensitive behavior.

[0046] As an example, the specified program interface corresponding to the sensitive behavior of background recording involves: a program interface that allows the application to run in the background, and a program interface that allows the application to perform the recording function.

[0047] Therefore, to ensure the program interface set covers as comprehensively as possible, and considering the accuracy and consistency of detection, these specified program interfaces can include, but are not limited to, all interfaces that implement related functions at the operating system level. All interfaces that implement related functions at the operating system level are provided by the platform or operating system framework, have unified naming conventions and functional definitions, and therefore their calling methods and usage are more consistent. In addition, system-level program interfaces cover a wide range of applicable functions and operations. Including such interfaces in the program interface set can cover more sensitive behavior types, ensuring that the execution results of subsequent steps are more comprehensive, improving accuracy and reliability, and reducing the risk of false positives and false negatives.

[0048] In this embodiment, the specified templated text is a privacy policy description templated for a specified sensitive behavior. Such a description includes, but is not limited to: describing the timing and manner in which the privacy behavior occurs, the data related to user privacy involved in the behavior, the data processing method, and whether it is transferred outside the local machine, etc.

[0049] In some feasible embodiments, after step S20 above, the privacy policy generation method may further include: determining whether the identification result is empty; if yes, returning to step S10; if no, executing step S30.

[0050] In this embodiment, there may be a situation where a specified program interface that matches the target program interface cannot be found from the preset set of sensitive behaviors. In this case, the identification result is considered to be empty, that is, the component object does not have any calls involving sensitive behaviors, and the privacy policy does not need to be disclosed. Therefore, it is no longer necessary to execute the subsequent step S30, and the process can return to execute the above step S10 to re-scan for sensitive behaviors.

[0051] Reference Figure 2 In some feasible embodiments, step S20 above may specifically include:

[0052] Step S21: Match the target program interface with the specified program interface. If the match is successful, use the specified program interface as the recognition result.

[0053] In this embodiment, the matching process may involve querying a specified program interface that matches the target program interface from a preset set of sensitive behaviors. After a successful match, the specified program interface that matches the target program interface from the preset set of sensitive behaviors may be directly identified and recorded, and used as the identification result.

[0054] Based on step S21 above, step S30 above may specifically include:

[0055] Step S31: Using the specified program interface as a keyword, query the specified templated text corresponding to the keyword in the preset sensitive behavior set;

[0056] Step S32: Use the specified templated text corresponding to the keywords as the privacy policy statement corresponding to the sensitive behaviors.

[0057] In this embodiment, when the identification result is a specified program interface, the specified program interface can be used as a keyword to query in the preset sensitive behavior set to obtain the specified templated text corresponding to the specified program interface, and then used as the privacy policy statement corresponding to the target program interface and the scanned sensitive behavior.

[0058] Reference Figure 3In some feasible embodiments, step S20 above may further include:

[0059] Step S22: Match the target program interface with the specified program interface. If the match is successful, use the specified sensitive behavior corresponding to the specified program interface as the identification result.

[0060] In this embodiment, the matching process may involve querying a specified program interface that matches the target program interface from a preset set of sensitive behaviors. After a successful match, the specified program interface that matches the target program interface from the preset set of sensitive behaviors may be identified and recorded. Then, the identified and recorded specified program interface may be mapped to the preset set of sensitive behaviors, and the matching may be performed again to determine the specified sensitive behavior corresponding to the specified program interface. The matched specified sensitive behavior may be used as the identification result.

[0061] Based on step S22 above, step S30 above may further include:

[0062] Step S33: Using the specified sensitive behavior as a keyword, query the specified templated text corresponding to the keyword in the preset sensitive behavior set;

[0063] Step S34: Use the specified templated text corresponding to the keywords as the privacy policy statement corresponding to the sensitive behaviors.

[0064] In this embodiment, if the identification result is a specified sensitive behavior, the specified sensitive behavior can be used as a keyword to query in a preset set of sensitive behaviors, obtain the specified templated text corresponding to the specified sensitive behavior, and use it as the privacy policy statement corresponding to the scanned sensitive behavior.

[0065] In some feasible embodiments, the aforementioned privacy policy statement is templated text, which includes both fixed and variable text; step S40 may specifically include:

[0066] Step S41: Instantiate the variable text based on the component object and specified sensitive behaviors to obtain the instantiated text;

[0067] Step S42: Assemble the fixed text and the instantiated text to generate the privacy policy text.

[0068] In this embodiment, the templated text may contain fixed and variable parts. Keywords can be considered variable parts, representing information specific to the scanned component, and are instantiated in specific steps based on the scanned application and specific sensitive behaviors.

[0069] As an example, such variable parts include, but are not limited to: application name and developer information, scope and purpose of data collection, data processing methods and security measures, user rights and choices, and the effective date and update method of the privacy policy.

[0070] In some feasible embodiments, the variable text mentioned above serves as a placeholder for the keyword to be filled; step S41 may specifically include:

[0071] Step S411: Use the name of the component object and the specified sensitive behavior as keywords to fill in the placeholders.

[0072] In this embodiment, as an example, the variable parts in the templated text can be placed using the XLIFF exchange file format, or other feasible methods can be used. When using the XLIFF file format as placeholders, the instantiation process is the process of filling in the XLIFF placeholders. Specific methods include, but are not limited to: for the assembled privacy policy, manually filling in the placeholders; for the assembled privacy policy, filling in the placeholders using information such as the application name, the program interface name of the privacy behavior, the permission name of the privacy behavior, and whether the application is connected to the internet.

[0073] In some feasible embodiments, after step S40 above, the privacy policy generation method may further include:

[0074] Step S50: Compare the privacy policy text with the existing privacy policy text of the component object to obtain the comparison result;

[0075] Step S51: If the comparison result shows that the privacy policy text is different from the existing privacy policy text, output a privacy policy text update prompt.

[0076] In this embodiment, the newly generated privacy policy text can also be compared with the existing privacy policy text of the scanned component object. If the comparison result shows that the newly generated privacy policy text is different from the existing privacy policy text, it can be displayed in a visual element or other form to notify the developer or user that a new sensitive behavior has been discovered. If the comparison result shows that the newly generated privacy policy text is the same as the existing privacy policy text, no update prompt will be output.

[0077] Furthermore, this application embodiment also provides a privacy policy generation device, referring to Figure 4 , Figure 4 A schematic diagram of a privacy policy generation device provided in this application embodiment is shown below. Figure 4 As shown, in this embodiment, the privacy policy generation device includes: a sensitive behavior scanning module 101, a sensitive behavior identification module 102, a privacy policy matching module 103, and a privacy policy assembly module 104.

[0078] Sensitive behavior scanning module 101 is configured to scan component objects for sensitive behaviors and record the target program interface where sensitive behaviors are detected.

[0079] Sensitive behavior recognition module 102 is configured to recognize sensitive behaviors of the target program interface based on a preset set of sensitive behaviors and record the recognition results;

[0080] The privacy policy matching module 103 is configured to determine the privacy policy statement corresponding to the sensitive behavior from the preset sensitive behavior set based on the identification result.

[0081] Privacy policy assembly module 104 is configured to assemble the privacy policy statements according to preset rules to generate privacy policy text.

[0082] In some feasible embodiments, the privacy policy generation apparatus may further include:

[0083] The data warehouse module 105 is configured to persist the specified sensitive behaviors that need to be disclosed in the privacy policy, thereby obtaining a preset set of sensitive behaviors; wherein, the preset set of sensitive behaviors includes corresponding specified sensitive behaviors, specified program interfaces and specified templated text.

[0084] Reference Figure 5 In some feasible embodiments, the privacy policy generation apparatus may further include:

[0085] The component receiving module 106 is configured to provide an interactive interface for receiving component objects to be scanned.

[0086] The scan result display module 107 is set to display the scan results, showing the privacy behavior program interfaces identified by the scan and the generated privacy policy text on the interface.

[0087] In this embodiment, an interactive interface is added to the privacy policy generation device provided in the aforementioned embodiments to facilitate users' more intuitive viewing of the privacy policy. This interface can display either the scanned and identified sensitive behavior program interfaces or the generated privacy policy text, or both can be displayed simultaneously. The specific content displayed includes... Figure 5In addition to the content shown, the following may also be included, but are not limited to: 1) using charts, icons, colors, and other visual elements to make it easier for users to understand and pay attention to sensitive behaviors; 2) categorizing sensitive behavior program interfaces and displaying them using various visual elements from a category perspective; 3) interactive functions, such as search, filtering, and sorting, allowing developers or users to customize the displayed content according to their needs and preferences; 4) comparing the generated privacy policy with the existing privacy policy of the scanned component object and displaying it in visual elements or other forms to notify developers or users of the discovery of new sensitive behaviors; 5) other forms or interactive interfaces that achieve the same purpose.

[0088] The privacy policy generation device provided in this embodiment belongs to the same technical concept as the privacy policy generation method provided in the above embodiments. Technical details not described in detail in this embodiment can be found in any of the above embodiments. Furthermore, this embodiment has the same beneficial effects as the privacy policy generation method.

[0089] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs.

[0090] Furthermore, this application also provides an electronic device. The aforementioned method for generating a privacy policy applied to the electronic device can be executed by a privacy policy generation device, which can be implemented through software and / or hardware and integrated into the electronic device. The electronic device can be a PC (personal computer), mobile phone, laptop, tablet computer, or other terminal device capable of communicating with the network side.

[0091] Reference Figure 6 , Figure 6 This is a schematic diagram of the hardware structure of an electronic device provided in an embodiment of this application. Figure 6As shown, the electronic device may include: a processor 1001, such as a central processing unit (CPU), a communication bus 1002, a user interface 1003, a network interface 1004, and a memory 1005. The communication bus 1002 is used to enable communication between these components. The user interface 1003 may include a display screen or an input unit such as a keyboard; optionally, the user interface 1003 may also include a standard wired interface or a wireless interface. The network interface 1004 may optionally include a standard wired interface or a wireless interface (such as a Wi-Fi interface). The memory 1005 may be high-speed random access memory (RAM) or stable non-volatile memory (NVM), such as a disk drive. The memory 1005 may also optionally be a storage device independent of the aforementioned processor 1001.

[0092] Those skilled in the art will understand that Figure 6 The structures shown do not constitute a limitation on the electronic device and may include more or fewer components than illustrated, or combine certain components, or have different component arrangements. Figure 6 As shown, the memory 1005, which serves as a storage medium, may include an operating system, a data storage module, a network communication module, a user interface module, and computer programs.

[0093] exist Figure 6 In the electronic device shown, the network interface 1004 is mainly used for data communication with other devices; the user interface 1003 is mainly used for data interaction with the user; the processor 1001 and the memory 1005 in this embodiment can be set in the electronic device. The electronic device calls the computer program stored in the memory 1005 through the processor 1001 and executes the privacy policy generation method for the electronic device provided in any of the above embodiments.

[0094] The electronic device proposed in this embodiment and the privacy policy generation method for electronic devices proposed in the above embodiments belong to the same technical concept. Technical details not described in detail in this embodiment can be found in any of the above embodiments, and this embodiment has the same beneficial effects as the privacy policy generation method.

[0095] Furthermore, embodiments of this application also provide a computer-readable storage medium, which may be a non-volatile computer-readable storage medium, on which a computer program is stored, and which, when executed by a processor, implements the privacy policy generation method provided in any of the above embodiments.

[0096] In addition, this application also provides a computer program product, including a computer program that, when executed by a processor, implements the privacy policy generation method provided in any of the above embodiments.

[0097] The computer program product provided in this application and the privacy policy generation method for electronic devices proposed in the above embodiments belong to the same technical concept. Compared with related technologies, the beneficial effects of the computer program product provided in this application are the same as the beneficial effects of the privacy policy generation method provided in the above embodiments, and will not be elaborated here.

[0098] It will be understood by those skilled in the art that all or some of the steps and systems in the methods disclosed above can be implemented as software, firmware, hardware, and suitable combinations thereof. Some or all of the physical components can be implemented as software executed by a processor, such as a central processing unit, digital signal processor, or microprocessor, or as hardware, or as an integrated circuit, such as an application-specific integrated circuit. Such software can be distributed on a computer-readable medium, which can include computer storage media (or non-transitory media) and communication media (or transient media). As is known to those skilled in the art, the term computer storage media includes volatile and non-volatile, removable and non-removable media implemented in any method or technology for storing information (such as computer-readable instructions, data structures, program modules, or other data). Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technologies, CD-ROM, digital versatile disc (DVD) or other optical disc storage, magnetic cartridges, magnetic tape, disk storage or other magnetic storage devices, or any other medium that can be used to store desired information and is accessible to a computer. Furthermore, as is known to those skilled in the art, communication media typically contain computer-readable instructions, data structures, program modules, or other data in modulated data signals such as carrier waves or other transmission mechanisms, and may include any information delivery medium.

[0099] The above describes some implementation methods of the embodiments of this application. However, the embodiments of this application are not limited to the above implementation methods. Those skilled in the art can make various equivalent modifications or substitutions without departing from the spirit of the embodiments of this application. All such equivalent modifications or substitutions are included within the scope defined by the claims of the embodiments of this application.

Claims

1. A method for generating a privacy policy, characterized in that, The method for generating the privacy policy includes: Perform sensitive behavior scanning on component objects and record the target program interfaces where sensitive behaviors are detected; Sensitive behaviors of the target program interface are identified based on a preset set of sensitive behaviors, and the identification results are recorded. Based on the identification results, determine the privacy policy statement corresponding to the sensitive behavior from the preset set of sensitive behaviors; The privacy policy statements are assembled according to preset rules to generate the privacy policy text.

2. The privacy policy generation method as described in claim 1, characterized in that, Prior to the step of identifying sensitive behaviors of the target program interface based on a preset set of sensitive behaviors, the privacy policy generation method further includes: The specified sensitive behaviors that need to be disclosed in the persistent privacy policy are obtained to form the preset set of sensitive behaviors; the preset set of sensitive behaviors includes the specified sensitive behaviors, specified program interfaces and specified templated text that correspond to each other.

3. The privacy policy generation method as described in claim 2, characterized in that, The specified program interface includes all program interfaces that need to be called in order to implement the specified sensitive behavior.

4. The privacy policy generation method as described in claim 2, characterized in that, The step of identifying sensitive behaviors of the target program interface based on a preset set of sensitive behaviors and recording the identification results includes: The target program interface is matched with the specified program interface. If the match is successful, the specified program interface is used as the identification result.

5. The privacy policy generation method as described in claim 4, characterized in that, The step of determining the privacy policy statement corresponding to the sensitive behavior in the preset sensitive behavior set based on the identification result includes: Using the specified program interface as a keyword, search for the specified templated text corresponding to the keyword in the preset sensitive behavior set; The specified templated text corresponding to the keyword will be used as the privacy policy statement corresponding to the sensitive behavior.

6. The privacy policy generation method as described in claim 2, characterized in that, The step of identifying sensitive behaviors of the target program interface based on a preset set of sensitive behaviors and recording the identification results includes: The target program interface is matched with the specified program interface. If the match is successful, the specified sensitive behavior corresponding to the specified program interface is taken as the identification result.

7. The privacy policy generation method as described in claim 6, characterized in that, The step of determining the privacy policy statement corresponding to the sensitive behavior in the preset sensitive behavior set based on the identification result includes: Using the specified sensitive behavior as a keyword, query the specified templated text corresponding to the keyword in the preset sensitive behavior set; The specified templated text corresponding to the keyword will be used as the privacy policy statement corresponding to the sensitive behavior.

8. The privacy policy generation method as described in claim 2, characterized in that, The privacy policy statement is templated text, which includes both fixed and variable text. The step of assembling the privacy policy statements according to preset rules to generate privacy policy text includes: The variable text is instantiated based on the component object and the specified sensitive behavior to obtain instantiated text. The fixed text and the instantiated text are assembled to generate the privacy policy text.

9. The privacy policy generation method as described in claim 8, characterized in that, The variable text serves as a placeholder for the keywords to be filled in; The step of instantiating the variable text based on the component object and the specified sensitive behavior includes: The placeholders are filled with the name of the component object and the specified sensitive behavior as keywords.

10. The privacy policy generation method as described in claim 1, characterized in that, After the step of assembling the privacy policy statements according to preset rules to generate privacy policy text, the method further includes: The privacy policy text is compared with the existing privacy policy text of the component object to obtain the comparison result; If the comparison result shows that the privacy policy text is different from the existing privacy policy text, an update prompt for the privacy policy text will be output.

11. An electronic device, characterized in that, The electronic device includes: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the computer program, when executed by the processor, implements the privacy policy generation method as described in any one of claims 1 to 10.

12. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, implements the privacy policy generation method as described in any one of claims 1 to 10.

Images