Methods, devices, and electronic equipment for encrypting and backing up printed documents

Abstract

This disclosure provides a method, apparatus, and electronic device for encrypting and backing up printed documents. One specific implementation of the method includes: generating Gaussian random noise data based on privacy data in the document to be printed and random interference with a preset seed number; selecting redundancy space in the document to be printed to obtain header file redundancy space; generating an embedded header file for the document to be printed based on the header file redundancy space and the Gaussian random noise data; in response to determining a verification result characterizing a verification consistency result, extracting noise data from the embedded header file for the document to be printed corresponding to the verification result to generate encrypted Gaussian random noise data; generating privacy data values ​​based on the encrypted Gaussian random noise data; and performing character conversion on the privacy data values ​​to generate original privacy data. This implementation reduces the possibility of privacy data leakage, improves the security of data backup, and enhances data integrity.

Description

Technical Field

[0001] The embodiments disclosed herein relate to the field of computer technology, and specifically to methods, apparatus, and electronic devices for encrypting and backing up printed documents. Background Technology

[0002] Print file encryption and backup is a technology for encrypting and backing up printed files. Currently, the common methods for encrypting and backing up printed files are: directly sending the printed files that need to be encrypted and backed up to the print queue or replacing the private data in the printed files.

[0003] However, when using the above methods to encrypt and back up printed documents, the following technical problems often arise:

[0004] Sending print files that require encryption and backup directly to the print queue lacks tamper resistance and may be intercepted, leading to privacy data leaks and low data backup security. Furthermore, because zero-perceptibility hiding of privacy data in print files is not possible, the size of the print files may change, resulting in lower data integrity. Summary of the Invention

[0005] The summary portion of this disclosure is intended to provide a brief overview of the concepts, which will be described in detail in the detailed description portion. This summary portion is not intended to identify key or essential features of the claimed technical solutions, nor is it intended to limit the scope of the claimed technical solutions.

[0006] Some embodiments of this disclosure provide methods, apparatus, and electronic devices for encrypting and backing up printed documents to address the technical problems mentioned in the background section above.

[0007] In a first aspect, some embodiments of this disclosure provide a method for encrypting and backing up printed documents. The method includes: generating Gaussian random noise data based on privacy data in the document to be printed and random interference with a preset seed number; selecting redundancy space for the document to be printed to obtain header file redundancy space; generating an embedded header file for the document to be printed based on the header file redundancy space and the Gaussian random noise data; performing data verification on the embedded header file to generate a verification result, wherein the verification result represents a verification consistency result and a verification inconsistency result; in response to determining that the verification result represents a verification consistency result, extracting noise data from the embedded header file corresponding to the verification result to generate encrypted Gaussian random noise data; generating privacy data values ​​based on the encrypted Gaussian random noise data; and performing character conversion on the privacy data values ​​to generate original privacy data.

[0008] Secondly, some embodiments of this disclosure provide a print file encryption and backup device, comprising: a first generation unit configured to generate Gaussian random noise data based on privacy data in the file to be printed and random interference with a preset seed number; a selection unit configured to select redundancy space in the file to be printed to obtain header file redundancy space; a second generation unit configured to generate an embedded header file of the file to be printed based on the header file redundancy space and the Gaussian random noise data; a verification unit configured to perform data verification on the embedded header file of the file to be printed to generate a verification result, wherein the verification result represents a verification consistency result and a verification inconsistency result; an extraction unit configured to extract noise data from the embedded header file of the file to be printed corresponding to the verification result in response to determining that the verification result represents a verification consistency result, to generate encrypted Gaussian random noise data; a third generation unit configured to generate privacy data values ​​based on the encrypted Gaussian random noise data; and a conversion unit configured to perform character conversion on the privacy data values ​​to generate original privacy data.

[0009] Thirdly, some embodiments of this disclosure provide an electronic device, including: one or more processors; and a storage device having one or more programs stored thereon, wherein when the one or more programs are executed by the one or more processors, the one or more processors implement the method described in any implementation of the first aspect above.

[0010] Fourthly, some embodiments of this disclosure provide a computer-readable medium having a computer program stored thereon, wherein the program, when executed by a processor, implements the method described in any of the implementations of the first aspect above.

[0011] The various embodiments disclosed above have the following beneficial effects: the print file encryption and backup methods of some embodiments of this disclosure reduce the possibility of privacy data leakage, improve the security of data backup, and improve data integrity. Specifically, the reasons for privacy data leakage, low data backup security, and low data integrity are: directly sending the print file that needs to be encrypted and backed up into the print queue lacks anti-tampering capabilities and may be intercepted, leading to privacy data leakage and low data backup security. Furthermore, because zero-perceptible hiding cannot be achieved when hiding privacy data in the print file, the size of the print file changes, resulting in low data integrity. Based on this, the print file encryption and backup methods of some embodiments of this disclosure first generate Gaussian random noise data based on the privacy data in the file to be printed and random interference with a preset seed number. This provides convenience for subsequent processing, using random interference with a preset seed number to protect the privacy data in the file to be printed, thus improving the security of data backup. Then, redundant space is selected from the above-mentioned file to be printed to obtain header file redundant space. Thus, the redundant space of the print file can be used to hide privacy data without changing the size of the print file, thereby achieving zero-perceptible hiding and improving data integrity. Next, based on the aforementioned header file redundancy space and Gaussian random noise data, an embedded header file for the printed document is generated. This maximizes the utilization of the header file redundancy space. Then, the embedded header file is validated to generate a validation result, which represents whether the validation is successful or not. This ensures the security of the embedded header file. Next, in response to the validation result indicating a successful validation, noise data is extracted from the corresponding embedded header file to generate encrypted Gaussian random noise data. This allows for the complete recovery of the Gaussian random noise data, ensuring data integrity. Third, privacy data values ​​are generated based on the encrypted Gaussian random noise data. This improves the tamper resistance of the privacy data values, preventing interception and reducing the possibility of privacy data leakage. Finally, the privacy data values ​​are converted to characters to generate the original privacy data. Therefore, the possibility of privacy data leakage is reduced, the security of data backup is improved, and data integrity is enhanced. Attached Figure Description

[0012] The above and other features, advantages, and aspects of the embodiments of this disclosure will become more apparent from the accompanying drawings and the following detailed description. Throughout the drawings, the same or similar reference numerals denote the same or similar elements. It should be understood that the drawings are schematic, and elements are not necessarily drawn to scale.

[0013] Figure 1This is a schematic diagram illustrating an application scenario of the print file encryption and backup method according to some embodiments of this disclosure;

[0014] Figure 2 This is a flowchart of some embodiments of the print document encryption and backup method according to this disclosure;

[0015] Figure 3 This is a schematic diagram of the structure of some embodiments of the print document encryption and backup device according to the present disclosure;

[0016] Figure 4 This is a schematic diagram of the structure of an electronic device suitable for implementing some embodiments of the present disclosure;

[0017] Figure 5 This is a diagram showing the hidden structure of a print file according to some embodiments of the print file encryption and backup device disclosed herein. Detailed Implementation

[0018] Embodiments of this disclosure will now be described in more detail with reference to the accompanying drawings. While some embodiments of this disclosure are shown in the drawings, it should be understood that this disclosure can be implemented in various forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided to provide a more thorough and complete understanding of this disclosure. It should be understood that the accompanying drawings and embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of protection of this disclosure.

[0019] It should also be noted that, for ease of description, only the parts relevant to the invention are shown in the accompanying drawings. Unless otherwise specified, the embodiments and features described in this disclosure can be combined with each other.

[0020] It should be noted that the concepts of "first" and "second" mentioned in this disclosure are used only to distinguish different devices, modules or units, and are not used to limit the order of functions performed by these devices, modules or units or their interdependencies.

[0021] It should be noted that the terms "a" and "a plurality of" used in this disclosure are illustrative rather than restrictive, and those skilled in the art should understand that, unless otherwise expressly indicated in the context, they should be understood as "one or more".

[0022] The names of messages or information exchanged between multiple devices in the embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of such messages or information.

[0023] This disclosure will now be described in detail with reference to the accompanying drawings and embodiments.

[0024] Figure 1This is a schematic diagram illustrating an application scenario of the print file encryption and backup method according to some embodiments of this disclosure.

[0025] exist Figure 1 In the application scenario, firstly, Gaussian random noise data 103 is generated based on the privacy data 101 in the file to be printed and the random interference 102 with a preset seed number. Redundancy space is selected for the file to be printed to obtain the header file redundancy space. Based on the header file redundancy space and the Gaussian random noise data, the embedded header file 104 is generated. Data verification is performed on the embedded header file to generate a verification result 105, where the verification result represents the verification consistency result and the verification inconsistency result.

[0026] It should be noted that computing devices can be either hardware or software. When a computing device is hardware, it can be implemented as a distributed cluster of multiple servers or terminal devices, or as a single server or terminal device. When a computing device is software, it can be installed on the hardware devices listed above. It can be implemented as, for example, multiple software programs or software modules used to provide distributed services, or as a single software program or software module. No specific limitations are made here. It should be understood that... Figure 1 The number of private data in the file to be printed can be any number depending on the implementation requirements.

[0027] Continue to refer to Figure 2 The diagram illustrates a flow 200 of some embodiments of a print document encryption and backup method according to the present disclosure. This print document encryption and backup method includes the following steps:

[0028] Step 201: Generate Gaussian random noise data based on the privacy data in the file to be printed and the preset number of random interference seeds.

[0029] In some embodiments, the entity executing the print file encryption and backup method (e.g., a computing device) can generate Gaussian random noise data based on the privacy data in the file to be printed and random interference with a preset seed number.

[0030] Here, the aforementioned "file to be printed" can refer to a file waiting to be printed. For example, the aforementioned "file to be printed" can refer to a PDF, Word, EXE, DLL, OCX, SYS, or COM format file waiting to be printed. The aforementioned "privacy data" can refer to strings in the file. The aforementioned "preset seed number random interference" can refer to a pre-set fixed number of seed number random interferences. For example, the aforementioned fixed number can refer to 42. The aforementioned "preset seed number random interference" can refer to [0.3745, 0.9507, 0.7320, 0.5987, 0.1560]. The aforementioned "Gaussian random noise data" can refer to noise data after Gaussian transformation. For example, the aforementioned "Gaussian random noise data" can refer to [0.23, -1.02, -0.56, -0.89, 1.45].

[0031] Optionally, the aforementioned execution entity can generate Gaussian random noise data by randomly interfering with the privacy data in the file to be printed and a preset seed number through the following steps:

[0032] The first step is to convert the private data in the document to be printed into characters to generate a sequence of private data values.

[0033] As an example, the aforementioned execution entity can convert the privacy data in the file to be printed into ASCII values ​​to generate a sequence of privacy data values. For example, if the privacy data in the file to be printed is "Hello", where "H" is converted to the ASCII value 72, "e" is converted to the ASCII value 101, "l" is converted to the ASCII value 108, and "o" is converted to the ASCII value 111, then the sequence of privacy data values ​​is [72, 101, 108, 108, 111].

[0034] The second step is to normalize the above-mentioned privacy data numerical sequence to generate a normalized privacy data numerical sequence.

[0035] As an example, the above execution entity can assume that the maximum value is 114 (ASCII code for r) and the minimum value is 32 (ASCII code for space). Then the normalized privacy data value sequence is [0.4386, 0.6930, 0.7544, 0.7544, 0.7719].

[0036] The third step involves performing a modulo operation on the normalized privacy data numerical sequence and the random interference with the preset seed number to generate the processed privacy data numerical sequence.

[0037] As an example, the aforementioned execution entity can perform an addition operation on the normalized privacy data numerical sequence and the aforementioned random interference with a preset seed number to generate a processed privacy data numerical sequence. For example, the processed privacy data numerical sequence is [0.8131, 0.6437, 0.4864, 0.3531, 0.9279].

[0038] The fourth step is to perform a Gaussian transform on the processed privacy data sequence to generate Gaussian random noise data.

[0039] As an example, the aforementioned executing entity can perform a Gaussian transformation on the processed privacy data numerical sequence using a standard normal distribution to generate Gaussian random noise data. For example, the Gaussian random noise data is [0.23, -1.02, -0.56, -0.89, 1.45].

[0040] Step 202: Select redundant space for the above-mentioned file to be printed to obtain the header file redundant space.

[0041] In some embodiments, the execution entity may select redundant space for the file to be printed to obtain header file redundant space.

[0042] Here, the aforementioned header file redundancy space may refer to the space in the header file of the printed document used to hide private data.

[0043] As an example, the execution entity described above can locate the header file region (e.g., e_lfnew offset) of the file to be printed to generate the header file region. Consecutive redundant bytes within this header file region are selected as header file redundancy space. These consecutive redundant bytes can refer to 100 consecutive bytes.

[0044] Step 203: Generate the header file to be printed after embedding, based on the above header file redundancy space and the above Gaussian random noise data.

[0045] In some embodiments, the execution entity may generate an embedded header file for the document to be printed based on the header file redundancy space and the Gaussian random noise data.

[0046] Here, the above-mentioned embedded header file to be printed can refer to a header file to be printed that contains the format of "hidden identifier, number of hidden data, hidden data content, seed number and slice code".

[0047] Optionally, the aforementioned execution entity can generate the embedded header file for the document to be printed by following these steps, based on the aforementioned header file redundancy space and the aforementioned Gaussian random noise data:

[0048] The first step is to construct a hidden identifier for the redundant space in the header file, which is an identifier containing information related to privacy data. For example, the format of the hidden identifier is [hidden identifier].

[0049] Here, the aforementioned hidden identifier can refer to an identifier containing information related to privacy data. For example, the aforementioned hidden identifier could be 0xCAFEF00D.

[0050] As an example, the aforementioned execution entity can write the hidden identifier into the first four consecutive free bytes in the header file's redundant space to obtain the hidden identifier. For instance, assuming the header file's redundant space is 00 00 00 00 00 00 00 00 0000 00…, writing the hidden identifier 0xCAFEF00D into the header file's redundant space will result in CA FE F0 0D 00 00 00 0000 0000 00….

[0051] The second step is to set the number of hidden data in the header file redundancy space to generate the number of hidden data, where the number of hidden data represents the precision of the hidden data.

[0052] Here, the aforementioned number of hidden data can refer to 28. For example, the format of the aforementioned number of hidden data can be [number of hidden data].

[0053] As an example, the aforementioned execution entity can write the hidden data quantity into the second consecutive 4 bytes of free space in the header file's redundancy space to obtain the hidden data quantity. For example, assuming the header file's redundancy space is 00 00 00 00 00 00 00 00 00 00…, writing the hidden data quantity 0x0000001C into the header file's redundancy space results in 00 00 00 00 00 00 00 1C 0000 00 00…. The third step involves constructing hidden data content from the header file's redundancy space to generate hidden data content, where the aforementioned hidden data content is private data.

[0054] Here, the aforementioned hidden data content can refer to [0.23, -1.02, -0.56, -0.89, 1.45]. For example, the format of the aforementioned hidden data content can be [hidden data content].

[0055] As an example, the aforementioned execution entity can first write the hidden data content into the first consecutive 28 bytes of free space in the header file's redundancy space to obtain the hidden data content. The fourth step is to set a seed number for the header file's redundancy space to generate the hidden data seed number.

[0056] Here, the seed number mentioned above can refer to 42. For example, the format of the seed number mentioned above can be [seed number].

[0057] As an example, the aforementioned execution entity can write the seed number into the third consecutive 4 bytes of free space in the header file's redundant space to obtain the seed number.

[0058] The fifth step is to construct a slice code for the redundant space of the header file to generate a hidden data slice code, where the hidden data slice code is the sequence number of the privacy data.

[0059] Here, the hidden data slice code mentioned above can refer to 0x0001. 0x0001 represents the first privacy data slice. For example, the format of the hidden data slice code mentioned above can be [hidden data slice code].

[0060] As an example, the aforementioned execution entity can write the above slice code into the first consecutive 2 bytes of free space after the seed number in the redundant space of the header file to obtain the slice code.

[0061] The sixth step is to combine the above-mentioned hidden identifier, the above-mentioned number of hidden data, the above-mentioned content of hidden data, the above-mentioned number of hidden data seeds, and the above-mentioned hidden data slice code into a hidden structure for printing the file.

[0062] Here, the above combination can refer to concatenation. For example, the hidden structure of a printed file is [hidden identifier][number of hidden data][hidden data content][number of seeds][hidden data slice code]. That is, [0xCAFEF00D]

[28] [0.23, -1.02, -0.56, -0.89, 1.45]

[42] [0x0001]. Figure 5 As shown, Figure 5 This is a diagram illustrating the hidden structure of a print file encryption and backup method according to some embodiments of this disclosure.

[0063] Step 7: Embed the above Gaussian random noise data into the header file redundancy space according to the above print file hidden structure to obtain the header file of the file to be printed after embedding.

[0064] Here, the Gaussian random noise data mentioned above can refer to [0.23, -1.02, -0.56, -0.89, 1.45], which, after being filled according to the above hidden structure of the print file, becomes [0xCAFEF00D]

[13] [0.23, -1.02, -0.56, -0.89, 1.45]

[42] [0x0001]. Then, the filled hidden structure of the print file is written into the header file redundancy space to obtain the embedded header file of the file to be printed.

[0065] Step 204: Perform data verification on the above-embedded header file of the document to be printed to generate verification results.

[0066] In some embodiments, the execution entity may perform data verification on the embedded header file to be printed to generate verification results, wherein the verification results represent verification consistency results and verification inconsistency results.

[0067] Optionally, the aforementioned executing entity can perform data verification on the embedded header file to be printed using the following steps to generate a verification result:

[0068] The first step is to perform hidden identifier matching on the header file of the embedded file to be printed to generate matching results.

[0069] As an example, the aforementioned execution entity can slide through the embedded header file to be printed byte by byte, determining the byte that matches the prefix as the hidden identifier. For example, the original hexadecimal data of the embedded header file to be printed is as follows (addresses starting from 0x0000): 0000: 00 00 00 00 00 CA FE F0 0D 13 00 00 00 DEAD BE EF… Bytes 5-8 are exactly CA FE F0 0D, indicating a prefix match, offset pos = 0x0005, and the content at 0x0005 is matched as the result of the hidden identifier match.

[0070] The second step is to verify the number of hidden data in the header file of the embedded file to be printed in response to the determination that the above matching result represents a consistent matching result, so as to generate a verification result.

[0071] Here, the matching result described above indicates that the matching result contains the hidden identifier. The verification result described above indicates whether the verification passed or failed. The verification described above can refer to a comparison. For example, if the number of hidden data in the header file of the file to be printed after embedding is 12, it is compared with the number of hidden data in the hidden structure of the printed file. If the number of hidden data is the same, the verification result indicates that the verification passed. If the number of hidden data is different, the verification result indicates that the verification failed.

[0072] The third step is to verify the seed number of the embedded header file to be printed in response to the determination that the above verification result indicates that the verification is successful, so as to generate the seed number verification result.

[0073] For example, if the number of hidden data in the header file of the file to be printed after embedding is 42, and this is compared with the number of seeds in the hidden structure of the printed file, then the seed number verification result indicates a consistent seed number verification result. If the seed numbers are different, then the seed number verification result indicates an inconsistent verification result.

[0074] Fourth, in response to the determination that the above seed number verification results indicate that the seed number verification is consistent, data integrity verification is performed on the above embedded header file to be printed to generate verification results.

[0075] As an example, the aforementioned execution entity can perform slice code verification on the embedded header file to be printed to generate a slice code verification result. Then, in response to determining that the slice code verification result represents a slice code verification consistency result, the slice code verification result is determined as the verification result.

[0076] Step 205: In response to determining that the above verification result represents the verification consistency result, noise data is extracted from the embedded header file of the file to be printed corresponding to the above verification result to generate encrypted Gaussian random noise data.

[0077] In some embodiments, the execution entity may, in response to determining that the verification result represents a verification consistency result, extract noise data from the embedded header file to be printed corresponding to the verification result to generate encrypted Gaussian random noise data.

[0078] Here, the aforementioned encrypted Gaussian random noise data can refer to the Gaussian random noise data embedded in the hidden structure of the print file within the header file of the file to be printed. That is, [0.23, -1.02, -0.56, -0.89, 1.45].

[0079] As an example, the aforementioned execution entity can extract noise data from the embedded header file of the file to be printed corresponding to the above verification result using wavelet transform to generate encrypted Gaussian random noise data.

[0080] Step 206: Generate privacy data values ​​based on the encrypted Gaussian random noise data mentioned above.

[0081] In some embodiments, the aforementioned execution entity may generate privacy data values ​​based on the aforementioned encrypted Gaussian random noise data.

[0082] Optionally, the aforementioned executing entity can generate privacy data values ​​based on the encrypted Gaussian random noise data through the following steps:

[0083] The first step is to perform an inverse Gaussian transform on the encrypted Gaussian random noise data to generate Gaussian random noise privacy data.

[0084] As an example, the aforementioned execution entity can perform an inverse Gaussian transformation on the encrypted Gaussian random noise data using an inverse cumulative distribution function (ICDF) to generate Gaussian random noise privacy data.

[0085] The second step is to perform an inverse modulo operation on the aforementioned Gaussian random noise privacy data to generate privacy data values.

[0086] As an example, the aforementioned execution entity can recover the value of the privacy data by multiplicative inverse to obtain the privacy data value.

[0087] In the process of adopting technical solutions to address the problems mentioned in the background section, the following issues often arise:

[0088] Hiding private data in printed documents can easily cause changes in file size, reducing the security of the private data. During printing, issues may arise where privacy data recovery fails, potentially leading to page order errors or missing data, causing physical damage.

[0089] Faced with the above-mentioned technical problems, the inventors decided to adopt the following solution:

[0090] Optionally, the aforementioned executing entity can generate privacy data values ​​based on the encrypted Gaussian random noise data through the following steps:

[0091] The first step is to encode the encrypted Gaussian random noise data to generate a sequence of integers representing the noise data.

[0092] As an example, the aforementioned execution entity can encode the encrypted Gaussian random noise data using UTF-8 encoding to generate a sequence of integer noise data.

[0093] The second step is to perform interval mapping on the above integer sequence of noise data to generate a mapped noise data sequence.

[0094] As an example, the aforementioned execution entity can divide each of the aforementioned noise data integers in the aforementioned noise data integer sequence by the difference between the maximum value and the minimum value in the aforementioned noise data integer sequence to generate mapped noise data, thereby obtaining a mapped noise data sequence.

[0095] The third step is to encrypt the above-mentioned mapping noise data sequence to generate a ciphertext vector.

[0096] As an example, the aforementioned executing entity can use the CKKS public key to encrypt the aforementioned mapped noisy data sequence to generate a ciphertext vector.

[0097] The fourth step is to perform homomorphic addition on the preset seed number and the above ciphertext vector to generate noisy ciphertext.

[0098] As an example, the aforementioned execution entity can first truncate the preset seed number to obtain the truncated seed number. For example, if the preset seed number is 42, the truncated seed number is 16. Then, the truncated seed number is added to the ciphertext vector and the modulo is taken to obtain the noisy ciphertext.

[0099] The fifth step is to map the above noisy ciphertext to Gaussian distributed ciphertext and to perform sparsification compression on the above Gaussian distributed ciphertext to generate a sparse ciphertext sequence.

[0100] As an example, the aforementioned execution entity can read standard normal random numbers from the noisy ciphertext in the Gaussian value table to generate Gaussian distributed ciphertext. Then, it stores the elements with the largest absolute values ​​in the Gaussian distributed ciphertext representing a preset percentage, and sets all elements outside the preset percentage to 0. The preset percentage is 30%.

[0101] The sixth step is to encode the above sparse ciphertext sequence to generate a binary embedding stream.

[0102] As an example, the aforementioned execution entity can encode the sparse ciphertext sequence using Golomb-Rice coding to generate a binary embedded stream.

[0103] Step 7: Define a pre-defined number of non-contiguous redundant areas in the header file of the printed document.

[0104] Here, the aforementioned preset number of non-continuous redundant areas can refer to four pre-defined non-continuous blank areas.

[0105] As an example, the aforementioned execution entity can be divided before the cross-reference table of the printed file header.

[0106] Step 8: Redundantly fragment the above binary embedded stream to generate a fragmented dataset, wherein the number of fragmented data in the fragmented dataset is equal to the number of preset segments.

[0107] As an example, the aforementioned execution entity can use RS(255, 223) erasure coding to perform equal-byte partitioning on the aforementioned binary embedded stream to generate a fragmented dataset. Here, "equal-byte" can refer to 3 bytes.

[0108] Step 9: Embed the above-mentioned fragmented dataset into the header file redundancy space to obtain the embedded file.

[0109] As an example, the aforementioned execution entity can sequentially write the fragmented data from the fragmented dataset into the header file redundancy space to obtain the embedded file. For example, the four data fragments fall at offsets of 0x80, 0x120, 0x1C0, and 0x240, with a total embedding of 256 bytes.

[0110] Step 10: Homomorphically decrypt the embedded file to generate a noisy normalized vector.

[0111] As an example, the aforementioned execution entity can recombine the embedded file to generate a recombined embedded file. Then, it performs additive inverse on the recombined embedded file and normalizes the vector after additive inverse to obtain a noisy normalized vector.

[0112] The eleventh step is to perform inverse normalization on the above noisy normalized vector to generate the processed vector.

[0113] As an example, the aforementioned execution entity can amplify the noisy normalized vector to the integer range of ASCII codes to generate the processed vector.

[0114] The twelfth step is to perform character conversion on the processed vector to generate privacy data values.

[0115] As an example, the aforementioned execution entity can convert the processed vector into an ASCII code value to generate a private data value. For instance, if the processed vector is "72", then "72" is converted to the ASCII code value "H".

[0116] The content described in steps one through twelve above constitutes an inventive point of this disclosure, solving the technical problem of "reduced security of privacy data, leading to page order disorder or partial data loss, causing physical-level failures." Factors causing page order disorder or partial data loss, resulting in physical-level failures, often include: When hiding privacy data in a printed document, the file size can easily change, leading to reduced privacy data security. During printing, privacy data restoration may fail, potentially causing page order disorder or partial data loss, resulting in physical-level failures. Solving these factors can improve the security of privacy data and prevent page order disorder or partial data loss. To achieve this, firstly, the encrypted Gaussian random noise data is encoded to generate a sequence of integer noise data. Then, the sequence of integer noise data is interval-mapped to generate a mapped noise data sequence. This keeps the file size constant, facilitating subsequent processing. Afterward, the mapped noise data sequence is encrypted to generate a ciphertext vector. This improves the security of privacy data. Next, a homomorphic addition is performed on the preset seed number and the aforementioned ciphertext vector to generate noisy ciphertext. This improves the security of privacy data. The noisy ciphertext is then mapped to Gaussian distributed ciphertext, and the Gaussian distributed ciphertext is sparsely compressed to generate a sparse ciphertext sequence. This sparse ciphertext sequence is then encoded to generate a binary embedded stream. This makes the sparse ciphertext sequence more concise. Next, a preset number of non-contiguous redundant regions are defined in the print file header. Then, the aforementioned binary embedded stream is redundantly fragmented to generate a fragmented dataset, where the number of fragmented data in the fragmented dataset equals the number of preset segments. This improves the utilization of redundant space. Then, the fragmented dataset is embedded into the header file's redundant space to obtain the embedded file. This facilitates data restoration and avoids physical-level failures caused by page order errors or missing data. Finally, the embedded file is homomorphically decrypted to generate a noisy normalized vector. This prevents the exposure of intermediate plaintext during decryption. Next, the noisy normalized vector is denormalized to generate a processed vector. This allows for the restoration of privacy data, preventing page order disruptions or missing data. Finally, the processed vector is converted to generate the privacy data value. Therefore, the security of privacy data is improved, preventing page order disruptions or missing data, thus avoiding physical-level failures.

[0117] Step 207: Convert the above privacy data values ​​into characters to generate the original privacy data.

[0118] In some embodiments, the aforementioned executing entity may perform character conversion on the aforementioned privacy data values ​​to generate original privacy data.

[0119] Here, the aforementioned character conversion can refer to the conversion of numerical values ​​to ASCII (American Standard Code for Information Interchange) codes. For example, if the value of the privacy data is 0.5647, after character conversion it is 0.5647 × 127, which is approximately equal to 72, i.e., the character is H.

[0120] Optionally, after "step 207" above, the method further includes:

[0121] The first step is to generate the original privacy dataset and the slice code set based on the multiple files to be printed received by the receiving end.

[0122] As an example, the aforementioned execution entity can determine Gaussian random noise data for each of the multiple files to be printed, generating Gaussian random noise data to obtain a Gaussian random noise dataset. Then, an inverse Gaussian transform is performed on the Gaussian random noise dataset using the inverse cumulative distribution function (ICDF) to obtain an inverse transform noise dataset. Next, ASCII code conversion is performed on each inverse transform noise data in the inverse transform noise dataset to generate original privacy data, resulting in an original privacy dataset. Finally, the hidden structure of the printable files for each of the multiple files to be printed is read using slice codes to generate slice codes, resulting in a slice code set.

[0123] The second step is to sort the above slice code set according to a preset sequence to generate a slice code sequence.

[0124] Here, the aforementioned preset sequence can refer to a pre-defined sequence from first to last.

[0125] As an example, the aforementioned execution entity can sort the aforementioned slice code set from first to last to generate a slice code sequence. For example, if the slice code set is "el", "H", and "lo", the slice code sequence after sorting from first to last is [H][el][lo].

[0126] The third step is to perform data aggregation and backup on the original privacy dataset based on the above slice code sequence to generate aggregated backup privacy data.

[0127] As an example, the aforementioned execution entity can, following the sequence of the slice codes, first concatenate the original privacy dataset to generate concatenated privacy data, for example, the concatenated privacy data being "Hello". Then, the concatenated privacy data is backed up and stored on a storage device. For example, the storage device could be a hard drive.

[0128] In the process of adopting technical solutions to address the problems mentioned in the background section, the following issues often arise:

[0129] Because the slice codes are stored in plaintext, they are easily tampered with, leading to disordered order in the aggregated backup. Furthermore, physical noise can be easily introduced during the data aggregation and backup of the original privacy dataset, causing random deviations in the slice codes, resulting in low security for the aggregated backup of privacy data.

[0130] Faced with the above-mentioned technical problems, the inventors decided to adopt the following solution:

[0131] Optionally, the aforementioned executing entity can perform data aggregation and backup on the original privacy dataset based on the aforementioned slice code sequence through the following steps to generate aggregated backup privacy data:

[0132] The first step is to add mixed noise to the above slice code sequence to generate a slice code noise sequence.

[0133] Here, the aforementioned mixed noise can refer to Laplace noise and Gaussian noise. For example, if the Gaussian noise is g ~ N(0, 0.1), i.e. [0.05, -0.08, 0.12, -0.03], and the Laplace noise is 1 ~ Lap(0, 0.2), i.e. [0.18, -0.10, -0.07, 0.25], then the mixed noise is n = g + 1, i.e. [0.23, -0.18, 0.05, 0.22]. Assuming the slice code sequence is represented by integers as C = [3, 1, 4, 2], the slice code noise sequence is C' = C + n = [3.23, 0.82, 4.05, 2.22].

[0134] The second step is to normalize the above slice code noise sequence to generate a normalized slice code noise sequence.

[0135] As an example, the aforementioned execution entity can normalize the slice code noise sequence using Z-score to generate a normalized slice code noise sequence. The range of the normalized slice code noise in the normalized slice code noise sequence is [0, 1]. For example, if the minimum value of C′ is 0.82 and the maximum value is 4.05, then the normalized slice code noise sequence is the slice code noise minus the minimum value divided by the maximum value minus the minimum value, i.e., (3.23-0.82) divided by (4.05-0.82) = 0.74. That is, the normalized slice code noise sequence is [0.74, 0.00, 1.00, 0.45].

[0136] The third step is to perform threshold filtering on the normalized slice code noise sequence to obtain the denoised slice code numerical sequence.

[0137] As an example, the aforementioned execution entity can replace the normalized slice code values ​​whose absolute values ​​are less than a preset threshold in the normalized slice code value sequence to obtain a denoised slice code value sequence. For example, the normalized slice code noise sequence is S = [s1, s2, ..., s...]. n ], with a preset threshold of T. For each element of S, perform the following: if |s i If |≤T, then let s i If ' = 0, otherwise retain the original value, i.e., s. i ′=s i The obtained S′=[s1′,s2′,…,s n [S′] is the denoised slice code numerical sequence. Here, the preset threshold is determined by the preset seed number through a pseudo-random number generator. Assuming T = 0.5, the denoised slice code numerical sequence S′ is [0.74, 0.00, 1.00, 0.00].

[0138] The fourth step is to perform inverse normalization on the above denoised slice code numerical sequence to generate the original integer slice code sequence.

[0139] As an example, the aforementioned execution entity can multiply each denoised slice code value in the denoised slice code value sequence by its standard deviation and then add it to the minimum value of the slice code noise sequence to generate the original integer slice code. The standard deviation is the maximum value minus the minimum value in the slice code noise sequence. For example, the original integer slice code in the original integer slice code sequence is 0.74 × (4.05 - 0.82) + 0.82 = 3.23, which, after rounding, is 3. That is, the original integer slice code sequence is [3, 1, 4, 1].

[0140] The fifth step is to establish an index table for the original integer slice code sequence to obtain the slice code index table.

[0141] As an example, the aforementioned execution entity can map each of the aforementioned original integer slice codes in the original integer slice code sequence to the physical location of the file fragment to generate a slice code index table. For example, the slice code index table is {3:0, 1:1, 4:2}.

[0142] Step 6: Based on the above slice code index table, perform hash verification on each piece of original privacy data in the above original privacy dataset to generate hash verification results and obtain a hash verification result set.

[0143] As an example, the aforementioned execution entity can perform SHA-256 hashing on each piece of raw privacy data in the aforementioned raw privacy dataset to generate raw privacy data results, resulting in a raw privacy data result set. Then, each piece of raw privacy data in the aforementioned raw privacy data result set is compared with the aforementioned slice code index table to generate hash verification results, resulting in a hash verification result set. The hash verification results in the aforementioned hash verification result set represent the sets of successful hash verification results and the sets of failed hash verification results.

[0144] Step 7: In response to the determination that all hash verification results in the above hash verification result set represent verification passed results, the above original privacy dataset is concatenated according to the order of the above slice code index table to generate concatenated privacy data, which serves as aggregated backup privacy data.

[0145] The content described in steps one through seven above constitutes an inventive point of this disclosure, solving the technical problem of "random deviations in slice codes leading to lower security in privacy data aggregation backup." Factors causing random deviations in slice codes and lower security in privacy data aggregation backup often include: Since slice codes are stored in plaintext, they are easily tampered with, leading to disordered backup order. Furthermore, physical noise is easily introduced during data aggregation backup of the original privacy dataset, causing random deviations in slice codes and lower security. Solving these factors can improve the security of privacy data aggregation backup. To achieve this, firstly, mixed noise is added to the slice code sequence to generate a slice code noise sequence. This improves the security of the slice code sequence. Then, the slice code noise sequence is normalized to generate a normalized slice code noise sequence. Finally, threshold filtering is applied to the normalized slice code noise sequence to obtain a denoised slice code numerical sequence. This improves the accuracy of the aggregation backup order and avoids random deviations in slice codes. The denoised slice code numerical sequence is denormalized to generate the original integer slice code sequence. An index table is then created for this original integer slice code sequence, resulting in a slice code index table. Next, based on the slice code index table, each original privacy data point in the original privacy dataset undergoes hash verification to generate a hash verification result set. This improves the security of the aggregated backup of privacy data. Subsequently, in response to the determination that all hash verification results in the hash verification result set represent successful verification, the original privacy dataset is concatenated according to the order of the slice code index table to generate concatenated privacy data, which serves as the aggregated backup privacy data. Therefore, threshold filtering improves the accuracy of the aggregated backup order, avoids random deviations in the slice codes, and enhances the security of the aggregated backup of privacy data.

[0146] Further reference Figure 3 As an implementation of the methods shown in the above figures, this disclosure provides some embodiments of a print file encryption and backup device, which are similar to... Figure 2 Corresponding to the method embodiments shown, this print document encryption and backup device can be specifically applied to various electronic devices.

[0147] like Figure 3As shown, the print file encryption and backup device 300 in some embodiments includes: a first generation unit 301, a selection unit 302, a second generation unit 303, a verification unit 304, an extraction unit 305, a third generation unit 306, and a conversion unit 307. The system comprises the following components: a first generation unit 301, configured to generate Gaussian random noise data based on privacy data in the file to be printed and random interference with a preset seed number; a selection unit 302, configured to select redundant space in the file to be printed to obtain header file redundancy space; a second generation unit 303, configured to generate an embedded header file for the file to be printed based on the header file redundancy space and the Gaussian random noise data; a verification unit 304, configured to perform data verification on the embedded header file to generate a verification result, wherein the verification result represents a verification consistency result and a verification inconsistency result; an extraction unit 305, configured to extract noise data from the embedded header file corresponding to the verification result in response to determining that the verification result represents a verification consistency result, to generate encrypted Gaussian random noise data; a third generation unit 306, configured to generate privacy data values ​​based on the encrypted Gaussian random noise data; and a conversion unit 307, configured to perform character conversion on the privacy data values ​​to generate original privacy data.

[0148] It is understandable that the units and references described in the printed document encryption and backup device 300 are... Figure 2 The steps in the described method correspond to each other. Therefore, the operations, features, and beneficial effects described above for the method also apply to the print document encryption and backup device 300 and the units contained therein, and will not be repeated here.

[0149] The following is for reference. Figure 4 It illustrates a schematic diagram of the structure of an electronic device (e.g., a computing device) suitable for implementing some embodiments of the present disclosure. Figure 4 The electronic device shown is merely an example and should not be construed as limiting the functionality or scope of the embodiments of this disclosure. Figure 4 As shown, the computer device includes a processor, memory, and a network interface connected via a system bus. The memory may include a non-volatile storage medium and internal memory. The non-volatile storage medium may store an operating system and a computer program. The computer program includes program instructions that, when executed, cause the processor to perform any of the methods described above. The processor provides computational and control capabilities to support the operation of the entire computer device. The internal memory provides an environment for the execution of the computer program in the non-volatile storage medium; when executed by the processor, the computer program causes the processor to perform any of the methods described above. The network interface is used for network communication, such as sending assigned tasks. Those skilled in the art will understand that... Figure 4The structure shown is merely a block diagram of a portion of the structure related to the present disclosure and does not constitute a limitation on the computer device to which the present disclosure is applied. A specific computer device may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0150] It should be understood that the processor can be a Central Processing Unit (CPU), but it can also be other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. Among these, a general-purpose processor can be a microprocessor or any conventional processor.

[0151] In one embodiment, the processor is configured to run a computer program stored in a memory to perform the following steps: generating Gaussian random noise data based on privacy data in a file to be printed and random interference with a preset seed number; selecting redundancy space for the file to be printed to obtain header file redundancy space; generating an embedded header file for the file to be printed based on the header file redundancy space and the Gaussian random noise data; performing data verification on the embedded header file to generate a verification result, wherein the verification result represents a verification consistency result and a verification inconsistency result; in response to determining that the verification result represents a verification consistency result, extracting noise data from the embedded header file to be printed corresponding to the verification result to generate encrypted Gaussian random noise data; generating privacy data values ​​based on the encrypted Gaussian random noise data; and performing character conversion on the privacy data values ​​to generate original privacy data.

[0152] This disclosure also provides a computer-readable storage medium storing a computer program, the computer program including program instructions, and the method implemented when the program instructions are executed can be referred to the various embodiments of the print document encryption and backup method of this disclosure.

[0153] The aforementioned computer-readable storage medium may be an internal storage unit of the computer device described in the foregoing embodiments, such as the hard disk or memory of the computer device. Alternatively, the aforementioned computer-readable storage medium may be an external storage device of the computer device, such as a plug-in hard disk, SmartMedia Card (SMC), Secure Digital (SD) card, or Flash Card equipped on the computer device.

[0154] It should be noted that, in this document, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or system that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or system. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or system that includes that element.

[0155] The above description is merely a selection of preferred embodiments of this disclosure and an explanation of the technical principles employed. Those skilled in the art should understand that the scope of the invention involved in the embodiments of this disclosure is not limited to the specific combinations of the above-described technical features, but should also cover other technical solutions formed by arbitrary combinations of the above-described technical features or their equivalents without departing from the above-described inventive concept. For example, the above features and embodiments of this disclosure...

[0156] The disclosed (but not limited to) technical features with similar functions are mutually substituted to form

[0157] The technical solution.

Claims

1. A method for encrypting and backing up printed documents, characterized in that, include: Gaussian random noise data is generated based on the privacy data in the file to be printed and random interference with a preset number of seeds. Redundancy space is selected from the file to be printed to obtain header file redundancy space; Based on the header file redundancy space and the Gaussian random noise data, generate the embedded header file for the document to be printed. The embedded header file to be printed is subjected to data verification to generate verification results, wherein the verification results represent verification consistency results and verification inconsistency results; In response to determining that the verification result represents a verification consistency result, noise data is extracted from the embedded header file of the file to be printed corresponding to the verification result to generate encrypted Gaussian random noise data; Generate privacy data values ​​based on the encrypted Gaussian random noise data; The value of the privacy data is converted into characters to generate the original privacy data; The generated privacy data values ​​include: The encrypted Gaussian random noise data is encoded to generate a sequence of integer noise data. The integer sequence of noise data is interval-mapped to generate a mapped noise data sequence; The mapped noise data sequence is encrypted to generate a ciphertext vector; Homomorphic addition is performed between a preset seed number and the ciphertext vector to generate noisy ciphertext; The noisy ciphertext is mapped to Gaussian distributed ciphertext, and the Gaussian distributed ciphertext is sparsified and compressed to generate a sparse ciphertext sequence. The sparse ciphertext sequence is encoded to generate a binary embedding stream; Define a preset number of non-contiguous redundant sections in the header file of the printed document; The binary embedded stream is redundantly fragmented to generate a fragmented dataset; The fragmented dataset is embedded into the header file redundancy space to obtain the embedded file; The embedded file is homomorphically decrypted to generate a noisy normalized vector; The noisy normalized vector is denormalized to generate a processed vector; The processed vector is then converted into characters to generate privacy data values.

2. The method for encrypting and backing up printed documents according to claim 1, characterized in that, The method further includes: In response to the receiving end receiving multiple files to be printed, an original privacy dataset and a slice code set are generated based on the multiple files to be printed; The slice code set is sorted according to a preset sequence to generate a slice code sequence; Based on the slice code sequence, the original privacy dataset is aggregated and backed up to generate aggregated backup privacy data; This includes generating the original privacy dataset and the slice code set, including: Gaussian random noise data is determined for each of the multiple files to be printed to generate Gaussian random noise data, thus obtaining a Gaussian random noise dataset. Perform an inverse Gaussian transform on the Gaussian random noise dataset to obtain an inverse transform noise dataset; Each inverse transform noise data in the inverse transform noise dataset is converted to ASCII code to generate the original privacy data, thus obtaining the original privacy dataset; The hidden structure of the print file of each of the multiple files to be printed is read by the slice code to generate a slice code, thus obtaining a slice code set; The process of aggregating and backing up the original privacy dataset to generate aggregated backup privacy data includes: Add mixed noise to the slice code sequence to generate a slice code noise sequence; The slice code noise sequence is normalized to generate a normalized slice code noise sequence. The normalized slice code noise sequence is subjected to threshold filtering to obtain a denoised slice code numerical sequence. The denoised slice code value sequence is denormalized to generate the original integer slice code sequence. An index table is established for the original integer slice code sequence to obtain the slice code index table; Based on the slice code index table, perform hash verification on each piece of original privacy data in the original privacy dataset to generate hash verification results and obtain a hash verification result set; In response to the determination that all hash verification results in the hash verification result set represent verification success results, the original privacy dataset is concatenated according to the order of the slice code index table to generate concatenated privacy data, which serves as aggregated backup privacy data.

3. The method for encrypting and backing up printed documents according to claim 1, characterized in that, The step of generating Gaussian random noise data based on privacy data in the file to be printed and random interference with a preset seed number includes: The privacy data in the print file is converted into characters to generate a sequence of privacy data values; The privacy data numerical sequence is normalized to generate a normalized privacy data numerical sequence. Modular operation is performed on the normalized privacy data numerical sequence and the preset seed number random interference to generate a processed privacy data numerical sequence; The processed privacy data numerical sequence is subjected to a Gaussian transform to generate Gaussian random noise data.

4. The method for encrypting and backing up printed documents according to claim 1, characterized in that, The step of generating privacy data values ​​based on the encrypted Gaussian random noise data includes: The encrypted Gaussian random noise data is subjected to inverse Gaussian transform processing to generate Gaussian random noise privacy data; The Gaussian random noise privacy data is subjected to inverse modulo operation to generate privacy data values.

5. The method for encrypting and backing up printed documents according to claim 1, characterized in that, The step of performing data verification on the embedded header file of the document to be printed to generate a verification result includes: The hidden identifier of the embedded header file to be printed is matched to generate a matching result; In response to determining that the matching result represents a consistent matching result, the number of hidden data in the embedded header file to be printed is verified to generate a verification result; In response to determining that the verification result indicates that the verification has passed, the seed number verification is performed on the embedded header file to be printed to generate a seed number verification result; In response to determining that the seed number verification result indicates that the seed number verification is consistent, data integrity verification is performed on the embedded header file to be printed to generate a verification result.

6. The method for encrypting and backing up printed documents according to claim 1, characterized in that, The step of generating the embedded header file for the document to be printed based on the header file redundancy space and the Gaussian random noise data includes: A hidden identifier is constructed for the redundant space of the header file to generate a hidden identifier, wherein the hidden identifier is an identifier containing information related to privacy data; The number of hidden data is set in the header file redundancy space to generate a number of hidden data, wherein the number of hidden data represents the precision of the hidden data; Hidden data content is constructed from the redundant space of the header file to generate hidden data content, wherein the hidden data content is privacy data; Set the seed number for header file redundancy space to generate the seed number for hidden data; The redundant space of the header file is used to construct a slice code to generate a hidden data slice code, wherein the hidden data slice code is the sequence number of the privacy data; The hidden identifier, the number of hidden data, the content of the hidden data, the number of hidden data seeds, and the hidden data slice code are combined into a hidden structure for the printed file; The Gaussian random noise data is embedded into the header file redundancy space according to the print file hidden structure to obtain the embedded print file header file.

7. A device for encrypting and backing up printed documents, characterized in that, include: The first generation unit is configured to generate Gaussian random noise data based on the privacy data in the file to be printed and random interference with a preset seed number. The selection unit is configured to select redundant space for the file to be printed, thereby obtaining header file redundant space; The second generation unit is configured to generate an embedded header file for the document to be printed based on the header file redundancy space and the Gaussian random noise data. The verification unit is configured to perform data verification on the embedded header file of the file to be printed in order to generate a verification result, wherein the verification result represents a verification consistency result and a verification inconsistency result; The extraction unit is configured to extract noise data from the embedded header file of the file to be printed corresponding to the verification result in response to determining that the verification result represents a verification consistency result, so as to generate encrypted Gaussian random noise data. The third generation unit is configured to generate privacy data values ​​based on the encrypted Gaussian random noise data; wherein, generating privacy data values ​​includes: The encrypted Gaussian random noise data is encoded to generate a sequence of integer noise data. The integer sequence of noise data is interval-mapped to generate a mapped noise data sequence; The mapped noise data sequence is encrypted to generate a ciphertext vector; Homomorphic addition is performed between a preset seed number and the ciphertext vector to generate noisy ciphertext; The noisy ciphertext is mapped to Gaussian distributed ciphertext, and the Gaussian distributed ciphertext is sparsified and compressed to generate a sparse ciphertext sequence. The sparse ciphertext sequence is encoded to generate a binary embedding stream; Define a preset number of non-contiguous redundant sections in the header file of the printed document; The binary embedded stream is redundantly fragmented to generate a fragmented dataset; The fragmented dataset is embedded into the header file redundancy space to obtain the embedded file; The embedded file is homomorphically decrypted to generate a noisy normalized vector; The noisy normalized vector is denormalized to generate a processed vector; The processed vector is then converted into characters to generate private data values; The conversion unit is configured to perform character conversion on the privacy data values ​​to generate the original privacy data.

8. An electronic device, characterized in that, include: One or more processors; A storage device on which one or more programs are stored; When the one or more programs are executed by the one or more processors, the one or more processors implement the method as described in any one of claims 1 to 6.

9. A computer-readable medium, characterized in that, It stores a computer program thereon, wherein the computer program, when executed by a processor, implements the method as described in any one of claims 1 to 6.

Images