WO1997012459A1

WO1997012459A1 - A method for encryption of file

Info

Publication number: WO1997012459A1
Application number: PCT/CN1995/000077
Authority: WO
Inventors: Xian Kan Lin
Original assignee: Xian Kan Lin
Priority date: 1995-09-26
Filing date: 1995-09-26
Publication date: 1997-04-03
Also published as: AU3560895A

Abstract

A method for encryption of file, comprising the steps of performing slide partition on source file block-by-block, each block being 128 bits; generating source key from user key by complementing the user key or by subjecting the user key to pseudo-random number processing; generating subkey from the source key through the use of compression permutation and logic shift; enciphering the blocks through the use of initial permutation, multiplicative conversion and inverse initial permutation, the multiplicative conversion using a cryptographic function including operations of extended conversion, exclusive OR of the subkey, box substitution and E conversion. The method is suitable for generating such digital information as voice and image etc... The executable file thus generated is provided to user in the form of software or being stored in memory, such as ROM and PROM, or being integrated into chips of various specifications, and is highly security and easy to use.

Description

File encryption processing method

The present invention relates to a file encryption processing technique in cryptographic technology, and more particularly, to a file encryption (decryption) processing method suitable for data processing. Background branch

Because information is a resource, there is a need for security protection. In computer storage and computer communication systems, information is composed of different combinations of "0" and "Γ", that is, all information is represented by data in the computer. For the security of data, Many data encryption technology schemes are available. Among them, the Data Encryption Standard (DES) algorithm is the current general data encryption method. However, this algorithm has the following disadvantages: (1) The amount of keys is 2 ^M. With the emergence of high-speed computers today, the amount of keys appears to be smaller ... Because the decipherer can use the exhaustive method to obtain the keys on the high-speed computers. This is for those more important information, which needs to keep the ciphertext for a long time. It is disadvantageous to use the same key for different encryption objects. (2) One of its foundations is the compressed replacement performed by a replacement secret box called 5_80. There are 8 replacement tables in the replacement secret box. In some alternative tables, the same element number exists in the same column number but different row number; and the same row number and column number have similar values in different alternative tables. Element value is more than ⁷⁶ pairs of such elements. (3) which transform E is an alternative symmetrical, which makes DES researchers and can transform E S_Box divided Lei analysis, this easy to decipher Ciphertext.

In the practical application of the DES algorithm, the CBC (Cipher Block Chaining) method has been used. This method has two disadvantages: (1) When any bit of the source file is changed, the target file cannot be changed. Every bit has the potential to change. (2) The initial variable IV (Initial Variable) needs to be encrypted for transmission. Object of the invention

The object of the present invention is to provide a method for processing file encryption in data processing, so that in a computer storage system and a computer communication system, the separation software is shaped or solidified in various RO PROMs or as the content of an operation system. One method that exists in the hard disk is to encrypt (or decrypt) a data file of a certain length and a certain format. Technical solutions In order to achieve the above-mentioned object of the present invention, the technical solution of the present invention is as follows: In a system composed of a conventional computer and its peripheral devices, under the control of an operating system, encryption (or decryption) work is performed on a user-defined target file. as follows:

First determined by the user: the working mode of encryption (or decryption); the source file name and its path; the target file name and its path; the user key.

According to the user's input above, the working mode (encryption or decryption) is recorded in the memory.

The user key is determined by the user, when it is acquired by a keyboard input, a total value of the ASCII code values ⁹⁵ to ⁷ EH 20H is used as the user key, the byte length which can 1-- vary between 16 When the length is less than 16 bytes, it is complemented to 16 bytes, and then the pseudo-random number processing is performed on the upper ⁴ bits of each byte of the user key entered by the keyboard, so as to form a 16-byte long source key; When the user key determined by the user is obtained from the memory, the 16-byte user key is directly used as the source key.

According to the obtained source key, a sub-key is obtained through transformation calculation such as compression permutation and logical shift.

The above steps to make up the 16-byte user key entered by the keyboard are:

Let the number of supplementary key bytes be the number of cycles, and use the first byte of the user key as the first noise source and the last byte as the second noise source. In the loop body, first multiply the first noise source by the first For the two voice sources, the product is divided by 10. If the lower 8 bits of the quotient are equal to zero, the upper 8 bits of the quotient are used as the supplementary key. If the lower 8 bits of the quotient are not equal to zero, the lower 8 bits of the quotient are used. To supplement the key, and then use the supplementary key as the second noise source. If the loop does not end and then returns to the beginning of the loop body, perform the operation in the loop body. If the loop ends, the first byte of the supplementary key is logically Multiply by 1FH.

The steps above to perform pseudo-random number processing on the upper 4 bits of each byte of the user key entered by the keyboard are as follows:

Take the byte length of the user key entered by the keyboard as the cycle number, the first byte of the user key entered by the keyboard as the first noise source, and the last byte as the second noise source, (if there is a supplementary key, then Use the last byte of the supplementary key as the second noise source). In the loop body, first multiply the first noise source by the second noise source, and divide the above product by 10. If the lower 8 bits of the quotient are equal to zero, use the upper 8 bits of the quotient as the second noise source. If the lower 8 bits of the key are not equal to zero, the lower 8 bits of the quotient are used as the second noise source; then the following operation is performed. If the upper 4 bits of the second noise source are equal to zero, the upper 4 bits of the key are XORed with the first The lower 4 bits of the second noise source. If the upper 4 bits of the second noise source are not equal to zero, the exclusive ⁴ bits of the key are XORed with the upper 4 bits of the second noise source. The second noise source in the above result is used as the lower The input of a loop is looped. If the loop does not end, it returns to the beginning of the loop body, and performs the operation in the loop body until the end of the loop is formed. 16-byte long source key;

The steps for calculating the sub-key from the source key through compression permutation and logical shift are as follows:

Calculate the sub-key from the source key. The 16-byte source key has 128 bits in total. The 128 bits are numbered sequentially from the beginning. The positions are numbered 1, 2, 3, ..., 127, 128. C. D. , And then logically shift to (: Α (Ϊ = 1,32), and output after compression and replacement of 2, where

The generation of C, (i = l, 32) is determined by the function and ς. _Ρ D _it respectively as shown in the following formula:

D ^ LM ^ D ^) (i = l, 32)

The function LMi represents a logical shift, as shown in Figure 8.

Compression substitution 1 is shown in Figure 7, and the 115th bit of the source key is taken as C. D. The first bit is the C bit. D. The second place, and so on, form a 112-bit long (:. D .;

Compression permutation 2 is shown in Figure ⁹ , with the 14th bit as the first bit, the 27th bit as the second bit, and so on, forming a 96-bit long sub-key K _i; For a subkey ^ (^ 1,32), the compression permutations 2 are all the same, but the corresponding ones are different.

According to the source file and path name determined by the user, the source file is read into the memory, and they are slidingly grouped, the number of sliding grouping code blocks is calculated, and the fragments are processed.

The above sliding grouping steps are as follows:

The source file is slidingly grouped, and the processing method is to encrypt the (or decryption) result of the previous group of code blocks by M (M is an integer, one of 1 to 4) bytes before the next code block. M bytes, in the forward sliding mode, such a set of code blocks is encrypted (or decrypted) to generate the same number of new code blocks, and then the aforementioned The digital sequence composed of new code blocks is slidingly grouped, that is, sliding grouping is started from the tail of the new data series in the reverse sliding operation mode. The processing method is to M words following the previous block of encryption (or decryption) results The section is the first M bytes of the next code block. After such a group of code blocks is encrypted (or decrypted), an object file corresponding to the source file is generated, that is, a ciphertext (or plaintext).

The above steps for calculating the number of sliding block code blocks are as follows:

The method of calculating the number of code blocks and the fragment length is to first take the byte length of the file and divide it by (16-M). For encryption, use (quotient + 1) as the quotient, and then take (U ⁶ -M)-the remainder) as the fragment. The block byte length gives the number of code blocks; if it is not encrypted, it directly gives the number of code blocks.

The above steps for processing fragments are as follows:

Processing fragments means processing some remaining plaintext information of the sliding grouping. Add some information to make it a set of data, the added information must contain a special information, that is, the fragment length, so that when decrypted, the newly added information is truncated to restore the original plain text's appearance completely, and the rest The newly added information is filled with a pseudo-random number. The method is to take (fragment length-1) as the cycle number, and the cycle number is equal to zero, and directly send the fragment length to the fragment area. If the cycle number is not equal to zero, the source secret is sent. The first byte of the key is used as the first noise source, and the last byte of the source key is used as the second noise source. In the loop body, the first noise source is first multiplied by the second noise source, and the above multiplication is divided by 10 If the lower 8 bits of the quotient are equal to zero, the upper 8 bits of the quotient are used as the second noise source, and if the lower ⁸ bits of the quotient are not equal to zero, the lower 8 bits of the quotient are used as the second noise source; The noise source is sent to the fragment area. If the end of the cycle ends, it returns to the beginning of the cycle body and performs the operation in the cycle body. At the end of the cycle, the fragment length is sent to the fragment area.

After the above processing, the code blocks of the obtained source file are encrypted (or decrypted). The encryption (or decryption) is performed in a reciprocating manner. The method is to start from the source file header for the first time. Sliding block code blocks for encryption (or decryption), the second time starts from the end of the file and proceeds in the reverse direction; the first is to use the number of code blocks as the cycle number, and point the source data address pointer and the target data address pointer to the beginning of the file buffer Address, in the loop body, first execute the encryption algorithm, and then increase the source data address pointer and target data address pointer (16 -M), the end of the loop returns to the beginning of the loop body, and execute the Operation, a new sequence of numbers is obtained at the end of the loop. Then perform reverse encryption (or decryption) on this new number sequence, and use the number of code blocks as the cycle number. Point the source data address pointer and the destination data address pointer to the 16th byte at the end of the new number sequence. In the loop body, first execute the encryption algorithm, and then reduce the source data address pointer, destination number and address pointer (16 -M), if the loop is not over, return to the beginning of the loop body, execute the 搡怍 in the loop body, If the cycle has ended, the ciphertext (or plaintext) corresponding to the source file is obtained. After the task is completed, the system returns to the operation system. The encryption algorithm is composed of initial permutation, multiplication, and inverse initial permutation. Input ²⁸ plain text (cipher text) and 32 subkeys with a length of 12 bytes. The output is 128-bit cipher text (plain text);

After the initial permutation the first embodiment shown in FIG. 16 is a 122 bit input data as a result of the initial permutation, the bit 2 of II ^4-bit input data as a result of the initial permutation, and so on, obtained by the initial permutation 128-bit output data.

The product transformation is a process of continuous iteration, performed a total of 32 times, the output of the initial replacement is used as the input of the first iteration, and the subsequent operation is to use the output of the previous iteration as the input of the next iteration, and the result of the 32nd iteration As the input of the inverse initial permutation; In FIG. 15, 0 is used to represent the odd number of data in each iteration of the output (or input), E is an even number of data, and F is the table. Shows the encryption function. During encryption, the sub-key K is used for the i-th iteration and 0 _{ι =} Ε _ί 1,32), decryption of the i-th iteration of the sub-key Κ _33, and Ε ^ Ο, ,, 0, ^ (0 ^) ©, (i = l, 32)...;

The scheme of the inverse initial permutation is shown in FIG. 17. The 80th bit of the final result of the product transformation is used as the first bit of the inverse initial permutation result, and the 16th bit of the final result of the product transformation is used as the second bit of the inverse initial permutation result. By analogy, 128 bits of output data after inverse initial permutation are obtained.

The encryption function F is the core of the algorithm. It consists of extended transformation, XOR sub-key operation, replacement of a secret box, and transformation E. For input 64-bit data, it is first extended and transformed into 96-bit data. The result of the extended transformation is XORed with the 96-bit sub-key, and the XOR result is 96-bit data, which is replaced by the secret box into 64-bit data, and finally transformed E to output 64-bit data;

The extended transformation FIG. 19 shows the rules of the extended transformation, which converts 64-bit input data into 96-bit output data, uses the 64th bit of the input sequence as the first bit of the output sequence, and the first bit of the input sequence As the second bit of the output sequence, we can do the same by analogy.

The secret box replacement is a compression replacement. There are 16 secret tables in each secret box of the present invention, and each secret table is divided into 4 rows × 16 columns. The input 96-bit data is divided into 16 groups in sequence, each group is 6 bits, and the replacement of each group corresponds to a secret table. In the 6-bit input data, the first 2 and the last 2 bits form the row number, and the middle 4 bits form the column number. , The row number and column number are extracted from the corresponding secret table as element output, and the output of each group is combined together in order to become the 64-bit replacement output data of the secret box;

The 16 secret tables that can have a secret box are shown in Fig. 20 and Fig. 21. If the positions of any two secret tables in the 16 secret tables shown in Fig. 20 and Fig. ^{2 (i} ) are reversed, another one is formed. A new secret box; if the positions of any two columns with the same column numbers shown in FIG. 20 and FIG. 21 are reversed at the same time (or the positions of any two columns with the same column numbers of the new new secret box are reversed at the same time) ), It also forms a new secret box. By analogy, we can know that the present invention proposes a ¾ box group with a total of (16!) ² secret boxes.

The transformation E is a kind of scrambling. It uses a pseudo-random number and another number (called RA) to perform an exclusive OR operation. The number obtained is still a pseudo-random number. The generation of the pseudo-random number and RA should be as far as possible with the transformation. The input data of E is related to the generation of the pseudo-random number sequence according to the formula

χ _{ι> 2} = (χ _ι · X _i ) M0D M at that time

The largest prime number where X ^ is smaller than Μ when X. ₂ = 1

Where M is a prime number and X. ≠ 0, Μ; χ ^ Ο, Ι, Μ; ΐ = 0,1, ..., (η-2), where η is the 64-bit data obtained by replacing the natural box with a secret box as the input of this process. Transform E The operation can be like this: First, the 64-bit input data is assigned to SXi (i = 0,7), SX,

7

The length is one byte; let the variable S be one byte long, according to the formula S = (SX) MOD 256, i = 0

7

Find S; if Let SX. = 241, SX _{1 =} 239. Then starting from the head of SX _; i = 0

Search for the first non-zero, non-251-valued byte. If found, use the byte as the first noise source. If not found, use 241 as the first noise source. Then start from the tail of SXi. At the beginning, it searches for the non-zero, non-one, and non-251 bytes that appear for the first time. If found, the byte is used as the second noise source. If it is not found, then 239 is used as the second noise source. Let 8 be the number of loops, and let the variable i = 0. In the loop body, the first stage operation is to multiply the first noise source by the second noise source, divide it by 251, and get the remainder R, The value of R®S @ SXi) is given to SXi. The second stage is to use the second noise source of this cycle as the first noise source of the next cycle and the remainder R as the second noise source of the next cycle. (If R = l, then use 239 as the second noise source). Then increase the variable i by 1, if the loop is not over, then return to the beginning of the loop body, execute 搡怍 in the loop body, and if the loop ends, output SX i-0,7) as the result of the encryption function F.

The transformation E can also be as follows: As shown in FIG. 22, the 64-bit incoming data is sequentially assigned to SX i ^), and the length of 5) ^ is one word, corresponding to the above-mentioned operation of transformation E, The corresponding changes can be based on the following facts: (1) in an unsigned integer, the maximum value of a byte is 255, the maximum value of a word is 65535; (2) in the range of one byte, the prime number The order from big to small is: 251, 241, 239, 233, and within a word range, the corresponding row '1 is: 65521, 65519, 65497, 65479,…. Drawing description

The specific content of the present invention will be clearly explained through the embodiments with reference to the accompanying drawings.

Figure 1. Schematic diagram of the overall hardware of the present invention

Figure 2. Overview of file encryption processing method

Figure 3. Procedure for obtaining source key from user key

Figure 4.Method procedure diagram of supplementary key.

Figure 5. Method diagram for processing the upper 4 bits of the user key

Figure 6. Method diagram for generating a subkey from a source key Figure 7. Method diagram of compression permutation 1

Figure 8. Logic shift function composition

Figure 9. Method diagram of compression permutation 2

Figure 10.Schematic diagram of forward sliding grouping

Figure 11 Schematic diagram of reverse sliding grouping

Figure 12.Procedure diagram for calculating the number of code blocks and the fragment length

Figure 13.Procedure diagram of a method for processing fragments

Figure:. Procedure for encrypting (or decrypting) the source file

Figure 15: Ladder diagram of data encryption algorithm

Figure 16.Initial replacement method diagram

Figure 17.Inverse initial permutation method diagram

Figure 18: Logic Diagram of Encryption Function

Figure 19.Extended transformation method diagram

Figure 20.The first 8 secret tables in the secret box

Figure 21.The last 8 secret tables in the secret box

Figure 22.Procedure diagram for transforming E

The file encryption processing method of the present invention is applied to a hardware environment such as: a computer storage system, a computer communication system, a central processing unit, an internal memory, a keyboard, a display, a disk drive, a printer, a communication interface, and a floppy disk. The inter-control bus, address bus, and data bus are connected together, as shown in Figure 1, where:

Memory block A (Figure 1) stores encrypted command files, and memory block B (Figure 1) stores encrypted (or decrypted) objects, that is, source files and target files. The starting address of memory block A is determined by the operating system. Memory block B Located at the high end of the computer memory, after the encryption command completes the encryption (or decryption) operation, the memory block B is controlled by the operation system;

Memory block A is provided with a one-byte physical unit that stores encryption (or decryption) operation mode information. The user's encryption (or decryption) request determines the content of the physical unit (not shown in Figure 1); The physical unit of the word is used to store the system information. It indicates whether the system is a Chinese operating system, an English operating system, or an operating system in another language (not shown in Figure 1);

According to the embodiment of the present invention, the logical relationship of completing the encryption (or decryption) work is shown in Figure 2. According to the screen power prompt, the user answers the following four questions: Encryption (or decryption) work Mode, source file name and its path, target file name and its path, using the user key; after the user determines the encryption (or decryption) mode on the keyboard, the memory block A stores the encryption (or decryption) The content of the physical unit of the pattern information is determined accordingly.

After the user enters the correct source file name and path, the size and starting address of memory block B can be determined according to the length of the source file and the use of memory resources, and the source file is read into memory block B ; Slidingly group the source files in the memory block B, calculate the number of sliding block code blocks and process the fragments, and then execute the encryption algorithm on each code block of the source file back and forth; when the entire content of the source file in the memory block B is After encrypting (or decrypting), write the ciphertext (or plaintext) in the target file;

When the user key is obtained from the keyboard, 95 code values can be used as the user key, and its ASCII code value is from 20H to 7EH; the byte length of the user key can be changed between 1 ~ 16, and then by the user The key obtained the source key;

The source key is obtained from the user key. When the user key length is less than 16 bytes, the key must be supplemented to a length of 16 bytes, and each byte of the user key obtained from the keyboard is supplemented. The upper 4 bits are used for pseudo-random number processing. After the above process, a 16-byte long source key is formed (see Figure 3 above);

Take the supplementary key byte amount as the number of cycles, the first byte of the user key as the first noise source, and the last byte as the second noise source. In the loop body, first multiply the first noise source by the second The source of the noise is divided by 10. If the lower 8 bits of the quotient are equal to zero, the upper 8 bits of the quotient are used as the supplementary key. If the lower 8 bits of the quotient are not equal to zero, the lower 8 bits of the quotient are used as the supplementary secret. Key, and then use the supplementary key as the second noise source. If the loop does not end and returns to the beginning of the loop body, perform the operation in the loop body. If the loop ends, multiply the first byte of the supplementary key by 1FH logically. (The above is shown in Figure 4);

The byte length of the user key is used as the number of cycles, the first byte of the user key is used as the first noise source, and the last byte is used as the second noise source. If a supplementary key is available, the last word of the supplementary key is used Section as a second noise source. In the loop body, first multiply the first noise source by the second noise source, and divide the above product by 10. If the lower 8 bits of the quotient are equal to zero, use the upper 8 bits of the quotient as the second noise source. If the lower 8 bits of the key are not equal to zero, then use the lower 8 bits of the quotient as the second noise source; then perform the following operation, and if the upper 4 bits of the second noise source are equal to zero, XOR the second upper 4 bits of the key The lower ⁴ bits of the noise source. If the upper 4 bits of the second noise source are not equal to zero, the exclusive 4 bits of the key are XORed with the upper ⁴ bits of the second noise source. The second noise source in the above result is used as the next one. The input of the loop is looped. If the loop does not end, it returns to the beginning of the loop body, and executes the operation in the loop body. If the loop ends, it enters the step of calculating the subkey (see Figure 5 above). As shown);

When the user key is obtained from the memory, the 16-byte user key is directly used as the source key;

The subkey is calculated from the source key. The 16-byte source key has a total of 128 bits. The 128 bits are numbered sequentially from the beginning. The positions are numbered 1, 2, 3, ..., 127, 128. C. D. , And then logically shift to (: = 1,32), and output after compressing and replacing 2 (as shown in Fig. 6), where (: (1 = 1, 32) shown in Fig. 6 is generated by a function! ^ ^ And ^ D _w are determined separately as shown by the following formula:

C = LM _i (C .. ₁ ^N ) (i = l, 32)

D. = L. (D. ^) (i = l, 32)

Where function represents a logical shift, see Figure 8;

Compression substitution 1 is shown in Fig. 7, and the 115th bit of the source key is taken as C. D. The first bit is the C bit. D. The second bit, and so on, forms C, which is 112 bits long. D. ; Compression permutation 2 is shown in Figure 9, with the 14th bit as the first bit of 27, the 27th bit as the second bit of K, and so on, forming a 96-bit long subkey K _i; When forming each sub-key Ki (i = 1, 32), the compression permutation 2 is the same, but the corresponding ones are different;

The source file is slidingly grouped. Preferably, the last two bytes of the encryption (or decryption) result of the previous group of code blocks are used as the first two bytes of the next code block. The forward sliding operation mode is shown in Figure 10. As shown, N is a natural number; such a set of code blocks is encrypted (or decrypted) to generate a new set of code blocks of the same set-number, and then the aforementioned new code blocks are formed in a reverse manner. The digital sequence is slidingly grouped, that is, starting from the tail of the new data series, as shown in Figure 11, where N is a natural number; the processing method is to encrypt (or decrypt) the last two words of the result of the previous group of code blocks. The section is the first two bytes of the next code block. After such a group of code blocks is encrypted (or decrypted), an object file corresponding to the source file is generated, that is, a ciphertext (or plaintext).

The method of calculating the number of code blocks and the fragment length is to first divide the byte length of the file by 14. For encryption, use (quotient + 1) as the quotient, and then (1. the remainder) as the fragment byte length. Number of code blocks; if it is not encrypted, directly give the number of code blocks, as shown in Figure 12,

Processing fragments means processing the remaining plaintext information of the sliding packet. The method is to add some information to make up a set of data. The added information must contain a special information, namely the fragment length, so that it can be decrypted when decrypted. Based on this, the newly added information is truncated to completely restore the original plain text appearance, and the remaining new information is filled with pseudo-random numbers. The method is to divide the (fragment length- 1) As the cycle number, the cycle number is equal to zero, and the fragment length is directly sent to the fragment area. If the cycle number is not equal to zero, the first byte of the source key is used as the first noise source, and the last byte of the source key is used as The second noise source, in the loop body, first multiply the first noise source by the second noise source, and divide the above product by 10. If the lower ⁸ bits of the quotient are equal to zero, use the upper 8 bits of the quotient as the second noise. Source, if the lower 8 bits of the quotient are not equal to zero, then use the lower 8 bits of the quotient as the second noise source; then send the second noise source to the fragment area, and if the end of the loop ends, return to the beginning of the loop body To perform the operations in the loop body, and send the fragment length to the fragment area at the end of the cycle, as shown in Figure 13; the encryption (or decryption) takes the form of reciprocating, which is the first time from the source file header The first time is to encrypt (or decrypt) each sliding block code block. The second time is to start from the end of the file and proceed in the reverse direction. The first is to count the number of code blocks as the number of cycles, and refer to the source data address pointer and the target data address. Point to the head of the file buffer In the loop body, first execute the encryption algorithm, and then increase the source data address pointer and the target data address pointer by 14, and return to the beginning of the loop body at the end of the loop. Perform the operation in the loop body and get the end of the loop. A new sequence of numbers. Then encrypt (or decrypt) the new digital sequence in the reverse manner, using the number of code blocks as the cycle number, and pointing the source data address pointer and destination data address pointer to the 16th byte at the end of the new digital sequence. In the body, first execute the encryption algorithm, and then reduce the source data address pointer and the target data address pointer by 14. If the loop is not ended, return to the beginning of the loop body, and execute the 搡怍 in the loop body. The ciphertext (or plaintext) corresponding to the source file. After the task is completed, return to the operation system, as shown in Figure 14;

The ladder diagram of the data encryption algorithm is shown in Figure 15. It consists of initial permutation, multiplication, and inverse initial permutation. Input 128-bit plaintext (ciphertext) and 32 subkeys with a length of 12 bytes. The output is 128. Bit ciphertext (plaintext), as shown in Figure 15;

The initial replacement scheme is shown in Figure 16. The 122nd bit of the input data is the first bit of the initial replacement result, the 114th bit of the input data is the second bit of the initial replacement result, and so on. 128-bit output data.

Product transformation is a process of continuous iteration, which is performed a total of 32 times. The output of the initial replacement is the input of the first iteration. The subsequent work is to use the output of the previous iteration as the input of the next iteration. The result 怍 is the input of the inverse initial permutation. In FIG. 15, 0 is used to represent the odd-numbered sections of the output (or input) data for each iteration, E is an even-numbered section, and F is an encryption function. The subkey κ was used for iteration, and 〇 ^ Ε ^, £ ^? (£ ^) © 0 ^, (1 = 1, 32). When decrypting, the subkey κ _{33 was} used for the i-th iteration. _ι and Ε Ο ^, 0 _: = F (O _i . ₁ ) © E _i . ₁ (i = l, 32); Inverse initial permutation scheme in FIG. 17, the first 16-bit result of the inverse initial permutation the first ^two final results of the inverse initial permutation 80 as a result of the final result of the conversion product of the transformation product, so By analogy, 128-bit output data after inverse initial permutation is obtained.

The encryption function F is the core of the algorithm. It consists of extended transformation, XOR sub-key operation, key box replacement, and transformation E. As shown in Figure 18, for inputting 64-bit data, it is first transformed into ^96- bit data. Data, and then XOR the result of the extended transformation with the 96-bit subkey to get the XOR result of 96-bit data, which is replaced by the secret box to 64-bit data, and finally transformed E, and output 64-bit data;

Figure I ⁹ shows the rules of extended transformation. It converts 64-bit input data into 96-bit output data, uses the 64th bit of the input sequence as the first bit of the output sequence, and the first bit of the input sequence as the output. The second position of the sequence, and so on, operates.

The secret box replacement is a compression replacement. There are 16 secret tables in each secret box in this embodiment, and each secret table is divided into 4 rows × 16 columns. The 16 secret tables with a secret box are shown in Fig. 20 and Fig. 21. If the positions of any two secret tables in the 16 secret tables shown in Fig. 20 and Fig. 21 are reversed, a new one is formed. Secret box; if the positions of any two columns with the same column numbers shown in FIG. 20 and FIG. 21 are reversed at the same time, or the positions of any two columns with the same numbers of the new new secret box are reversed at the same time. It also forms a new secret box. By analogy, it can be known that the present invention proposes a secret box group with a total of (16!) ² secret box groups. The input 96-bit data is divided into 16 groups in sequence, each group is 6 bits, and the replacement of each group corresponds to a secret table. In the 6-bit input data, the first and last 2 bits form the row number, and the middle 4 bits form the column. Number, according to this row number, column number in the corresponding secret table to extract the element value as output, the output of each group is combined together in turn. The output data of the secret box is 64 bits;

x _{i <2} = (x, · x ..,) M0D M when x ,. ₂ ≠ l

X-the largest prime number less than M when 1

Among them, M is a prime number, x _c ≠ 0, M; χ, ≠ 0, 1, Μ; ί = 0, 1, ··, (n-2), η is a natural number.

The 64-bit data obtained by substituting the secret box is used as the input of this process. The operation on the transformation E can be as follows: First, the 64-bit input data is sequentially assigned to SX _;

7

The length is one byte; let the variable S be one byte long, according to the formula S = (∑ SX ^ OD 256, i = 0 7

Find S; if 0, then SX. = 241, SX 239. Then from the beginning, i = 0

Search for the first non-zero non-251-valued byte. If found, use the byte as the first noise source. If it is not found, use 241 as the first noise source. Then start from the tail and reverse the order. Search for the first non-zero, non-one, and non-251-valued bytes. If found, use the byte as the second noise source. If not, use 239 as the second noise source. Let 8 be the number of loops, and let the variable i = 0. In the loop body, the first stage operation is to multiply the first noise source by the second noise source, divide the product by 251, and get the remainder R, and (RS ®SX,) to SX ^ The second stage is to use the second noise source in this cycle as the first noise source in the next cycle, and the remainder R as the second noise source in the next cycle, (if R = l , Then use 239 as the second noise source). Then increase the variable i by 1, if the loop is not over, then return to the beginning of the loop body, execute the operations in the loop body, and if the loop ends, output SXi (i = 0, 7) as the result of the encryption function F .

The operation of transforming E can also be as follows: As shown in FIG. 22, the 64-bit input data is sequentially assigned to SX i-0, 3) 'The length of SXi is one word, corresponding to the above-mentioned operation of transforming E, correspondingly The value of the change can be based on the following facts: (1) in an unsigned integer, the maximum value of a byte is 255, the maximum value of a word is 65535; (2) within the range of one byte, The order of the prime numbers from big to small is: 251, 241, 239, 233, and within a word range, the corresponding arrangement is: 65521, 65519, 65497, 65479,....

According to the file encryption processing method described above, in the implementation of the present invention described above, it may also be preferable to: form an external encryption command file in the form of a software system (for example, through programming, compilation, linking, etc.), Or an executable file with the suffix "EXE") or solidified in various ROMs, PROMs are made into LSI chips. It is also preferable that in the operation of the computer, it is not necessary to open a special data area for the data file in the program, but to apply to the operating system for an internal memory located at a high-end address, such as the memory block B shown in FIG. 1 , to place the data file to be sufficiently effective maximum memory hardware under conditions (in accordance with the present sticks for shoving system provides, one can encrypt data length of 1 megabyte file, i.e. can encrypt a nearly ⁵⁰ million words Chinese books). Conversely, decryption is no different. When programming, assembly language may be preferably used.

If the user considers it necessary, the target file generated by the first encryption can also be used as the source file of the second encryption, and so on. It can be encrypted multiple times, how many times the encryption is performed, and the same decryption. The number of times you can restore the previous plaintext. Encryption commands can be used in Chinese operating systems, English operating systems, or operating systems in other languages.

In computer storage systems and computer communication systems, the present invention can be applied to include text files, form files, graphic files, image files, library function files, and even executable files.

The data encryption method proposed by the present invention can also be used in real-time communication systems, including encryption and decryption for digital image signals and digital audio signals. Can also be used in radio communications.

The data file encryption processing method provided by the present invention includes that it can be used on a microcomputer, and can also be used on a small computer.

The data file encryption processing method provided by the present invention includes a single-user operation system and a multi-user operation system. Beneficial effect

Compared with the current domestic and foreign DES algorithms and their variants, the present invention has the following beneficial technical effects:

1. The key amount is 2 ^11∑ , and the key length obtained from the disk is variable.

2. The present invention proposes a secret box group with a total of (16!) ² secret boxes. In each alternative secret box, there are 16 secret tables; the elements of the same row number and column number in the 16 secret tables are different; in the 16 secret tables, the values of the elements on the same column are different and the same The elements on the line are also different. Therefore, every time the replacement of the secret box is implemented the "one time one secret" system.

3. Associate the transformation E with a pseudo-random number, making the transformation E a "black box". In encrypted correspondence, it is connected with the replacement secret box to become one. With this technical solution, the use of this algorithm is theoretically indecipherable.

4. Use a reciprocating sliding grouping method for data files. It has two benefits: U) Changing any bit value in the source file will make any bit in the target file changeable. (2:> The initial variable IV in the CBC is not required for the cipher block chaining method, which makes the invention easier to connect with the public key system. (3) It is more difficult to decipher.

5. Perform XOR operation on the upper 4 digits of the user key code value with the pseudo-random number sequence separately, which can prevent people's behavior habits from showing up in the cipher text, which increases the difficulty of deciphering.

6. In the present invention, it may be preferable to place the operation object, that is, the data file, at the high end of the computer memory. In this way, the memory can be fully utilized to encrypt (or decrypt) a data file of a certain length, and can also form an operation The external encryption command of the system enhances the function of the file management type command and enriches the content of the operating system. 7. Compared to those algorithms for shortening code blocks, since the length of each encrypted code block of the present invention is 16 bytes, it is easy to make the distribution of official text values between 0 and 255 more ideal.

The present invention has been described above with reference to the preferred embodiments of the present invention. It can be understood that those skilled in the art can make various improvements and modifications without departing from the spirit of the appended claims.

Claims

Claim 1. A file encryption processing method in a system composed of a conventional computer and its peripheral devices (including a computer storage system, a computer communication system, a central processing unit, a memory, a keyboard, a display, a disk drive, The printer, communication interface, and floppy disk are connected by control bus, address bus, and data bus.) Under the control of the operating system, the encryption (or decryption) of the target file specified by the user is performed as follows:

(1) Determined by the user: working mode of encryption (or decryption); source file name and path; target file name and path; user key;

(2) recording the working mode (encryption or decryption) in the memory according to the above input by the user;

(3) According to the user key determined by the user, when it is obtained from the memory, the 16-byte user key is directly used as the source key;

(4) According to the user key determined by the user, when it is obtained by keyboard input, a total of 95 ASCII code values from 2 OH to 7EH are used as the user key, and its byte length can be between 1-16 If the length is less than 16 bytes, the process to make it up to 16 bytes is:

Take the supplementary key byte amount as the number of cycles, the first byte of the user key as the first noise source, and the last byte as the second noise source. In the loop body, first multiply the first noise source by the first Two noise sources, the product of which is divided by 10. If the 8 digits of the quotient are equal to zero, the upper 8 digits of the quotient are used as the supplementary key. Key, and then use the supplementary key as the second noise source. If the loop does not end and then returns to the beginning of the loop body, perform the operation in the loop body. If the loop ends, multiply the first byte of the supplementary key by 1FH logically;

Then the pseudo-random number processing is performed on the upper 4 bits of each byte of the user key entered by the keyboard. The process is:

Take the byte length of the user key entered by the keyboard as the cycle number, the first byte of the user key entered by the keyboard as the first noise source, and the last byte as the second noise source, (if there is a supplementary key, then The last byte of the supplementary key is used as the second noise source), in the loop body, the first noise source is first multiplied by the second noise source, the above product is divided by 10, and if the lower 8 bits of the quotient are equal to zero, then The high 8 bits of the quotient are used as the second noise source. If the low 8 bits of the quotient are not equal to zero, the low ⁸ bits of the quotient are used as the second noise source. Then the following 搡怍 is performed. If 4 bits are equal to zero, the high 4 bits of the key are XORed with the lower 4 bits of the second noise source. If the high 4 bits of the second noise source are not equal to zero, the high 4 bits of the key are XORed with the second noise source. Upper 4 bits; loop through the second noise source in the above result as the input of the next loop, if the loop does not end, return to the beginning of the loop body, execute the 橾怍 in the loop body until the end of the loop, such as This forms a 16-byte long source key;

(5) According to the obtained source key, a sub-key is obtained through transformation calculation such as compression permutation and logical shift. The process is as follows:

Calculate the sub-key from the source key. The ^6- byte source key has 128 bits in total. The 128 bits are numbered I, ² , ³ , ..., 127, 128 in sequence from the beginning. Become C. D. , And then logically shift to CA -1, ³² ), and output after compression and replacement 2, where εΑ (ί = 1, ³ 2) is generated by the functions 1 ^ and (^, respectively, as shown by the following formula :

D ^ LM, (D ^ J (i = l, 32)

The function 1 ^ represents a logical shift, as shown in the following table:

Compression substitution 1 is shown in the following table, and the 115th bit of the source key is taken as C. D. The first bit is the C bit. D. The second bit, and so on, forms C, which is 112 bits long. D. ;

Replace ¾ (Article ²⁶ ) 1 15 99 83 67 5 1 35 19 3

1 17 101 85 69 53 37 21 5

1 19 103 87 71 55 39 23 7

123 107 91 75 59 43 27 1 1

125 109 93 77 61 45 29 13

127 111 95 79 63 47 31 15

1 14 98 82 66 50 34 18 2

128 1 12 96 80 64 48 32 16

126 1 10 94 78 62 46 30 14

124 108 92 76 60 44 28 12

122 106 90 74 58 42 26 10

120 104 88 72 56 40 24 8

118 102 86 70 54 38 22 6

1 16 100 84 68 52 36 20 4

Compression permutation ² is shown in the following table, with the 14th bit as the first bit of K, the 27th bit as the second bit of K, and so on, forming a 96-bit long subkey K, When forming each sub-key K, (i = l, 32), the compression permutation 2 is the same, but the corresponding ones are different;

14 27 31 1 6 101 93 80

4 94 43 26 67 59 15 97

23 57 36 75 50 109 39 9

49 106 69 7 32 72 86 52

102 66 28 78 112 11 38 60

91 8 87 47 81 62 17 103

54 96 16 88 34 110 84 42

73 58 85 21 99 51 2 79

45 111 46 89 56 10 74 68

55 5] 06 37 70 95 48 22

13 19 77 104 24 40 90 63

30 108 33 64 20 98 41 82

Replacement page (Article 26 of the Uranium Code) (6) reading the source file into the memory according to the source file and the path name determined by the user;

(7) Sliding grouping the source files, the steps are as follows:

Encrypt (or decrypt) the previous set of code blocks

The last two bytes of the result are the first two bytes of the next code block. In the forward sliding operation mode, such a set of code blocks are encrypted (or decrypted) to produce the same number of groups. The new code block of the new code block is then slidingly grouped in a reverse manner to the digital sequence composed of the foregoing new code block, that is, sliding grouping is started from the end of the new data series. The processing method is to encrypt the previous set of code blocks (Or decryption) The last two bytes of the result are used as the first two bytes of the next code block. After such a set of code blocks are encrypted (or decrypted), a target file corresponding to the source file is generated. Ie ciphertext (or plaintext);

(8) Calculate the number of sliding block code blocks and the fragment length for the source file. The steps are as follows: first divide the byte length of the file by 14;

(14-remainder) as the length of the fragmented byte, the number of code blocks is given to the quotient; if it is not encrypted, the number of code blocks is given directly to the quotient;

(9) Process the fragmentation of the source file, the steps are as follows:

For some remaining plaintext information of the sliding packet, add some information to make it a set of data. The added information must contain a special information, that is, the fragment length, so that when decrypted, the newly added information is truncated accordingly. The original plain text is completely restored, and the remaining new information is filled with pseudo-random numbers. The method is to use (fragment length-1) as the number of cycles, and the number of cycles is equal to zero, and directly send the length of the fragment to the fragment area; If the number is not equal to zero, the first byte of the source key is used as the first noise source, and the last byte of the source key is used as the second noise source. In the loop body, the first noise source is first multiplied by the second noise source. The above product is divided by 10. If the lower 8 bits of the quotient are equal to zero, the upper 8 bits of the quotient are used as the second noise source. If the lower 8 bits of the quotient are not equal to zero, the lower 8 bits of the quotient are counted as the first noise source. Two noise sources; then send the second noise source to the fragment area, if the end of the cycle ends, return to the beginning of the cycle body, perform the operation in the cycle body, and send the fragment length to the fragment area at the end of the cycle ;

(10) Encrypting (or decrypting) each code block of the obtained source file, which takes the form of reciprocating, the steps are as follows: The first time the source file header is used to encrypt (or Decryption), the second time starts from the end of the file and proceeds in the reverse direction; the first is to use the number of code blocks as the number of loops, and the source data address pointer and the target data address pointer both point to the first address of the file buffer. In the loop body, first Execute the encryption algorithm, and then increase the source data address pointer and the destination data address pointer by 14, return to the beginning of the loop body at the end of the loop, execute the operation in the loop body, and obtain a new sequence of numbers at the end of the loop. Then for this A new digital sequence is encrypted (or decrypted) in a reverse manner. The number of code blocks is used as the cycle number. Both the source data address pointer and the destination data address pointer are directed to the end of the new digital sequence at the 16th byte. In the encryption algorithm, the source data address pointer and the target data address pointer are both reduced by 14. If the loop is not ended, the loop body is returned to the beginning of the loop body, and the operation in the loop body is executed. The ciphertext (or plaintext) corresponding to the source file is returned to the operating system after the task is completed;

The encryption algorithm consists of an initial permutation, a product transform, and an inverse initial permutation. A 128-bit plaintext (ciphertext) and 32 subkeys with a length of 12 bytes are input, and the output is a 128-bit ciphertext (plaintext). ;

The initial replacement scheme is shown in the following table. The 122nd bit of the input data is the first bit of the initial replacement result, the 114th bit of the input data is the second bit of the initial replacement result, and so on. The next 128 bits of output data;

122 1H 106 98 90 82 74 66 58 50 34 26 18] 0 2

116 108 100 92 & i 76 68 60 62 36 28 20 12

126 118 110 102 Si 86 78 70 62 bi 46 38 30 22 M 6

128 120 112 104 96 88 80 72 64, 66 <8 40 32 IK 16 6

121 113 105 97 89 81 73 65 67 A 9 <1 33 25) 7 9 1

123 116 107 99 91 83 75 67 69 51 36 27 19 11 3

125 117 109 101 93 85 77 69 61 53 u 37 29 Ί 1 i 3 i>

127 119 1 I 1 103 95 87 79 71 63 55 39 3! 23 1 7

Product transformation is a process of continuous iteration, which is performed a total of 32 times. The output of the initial replacement is used as the input of the first iteration. The subsequent operation is to use the output of the previous iteration as the input of the next iteration. The result is used as the input of the inverse initial permutation. In FIG. 15, 0 is used to represent the odd-numbered sections of data in each iteration, E is an even-numbered section, and F is an encryption function. Iteratively used sub-keys K ,, and Ο, -Ε ^, E ^ FiE,,) © 0 ^ (1 = 1,32), when decrypting, the sub-key κ ₃₃ and E, = were used for the i-th iteration. , ^ O ^ FiO, (i = l, 32);

The scheme of the inverse initial permutation is shown in the following table. The 80th bit of the final result of the multiplicative transformation is the first bit of the inverse initial permutation result. The 16th bit of the final result of the product transformation is the second bit of the inverse initial permutation result. By analogy, the 128-bit output data after inverse initial permutation is obtained.

80 16 96 32 112 128 64 79 15 95 3] 111 127 63

78 M 94 30 110 126 62 77 13 93 29 109 125 61

76 12 92 28 108 a 124 60 75 "11 9) 27 107 i2 123 69

U 10 90 26] 06 <2 122 58 73 9 89 25 105 1 121 i) 7

72 8 88 H I (M AO 120 56 71 7 87 23 103 39 119 bi>

70 6 86 11 \ U2 38 118 54 69 b 85 21 101 3V i n 63

68 4 84 20 100 36 116 52 67 3 83 19 99 35 115 51

66 2 82 18 98 34 1 H 50 6S 1 81 17 97 33 113 49

The encryption function F is the core of the algorithm. It consists of extended transformation, XOR sub-key operation, replacement of the secret box, and transformation E. For the input 64-bit data, it is first extended and transformed into 96-bit data. XOR the result of the extended transformation with the 96-bit sub-key to obtain the XOR result of 96-bit data, and then replace the 64-bit data with the secret box. Finally, transform E to output 64-bit data;

The extended transformation is shown in the following table, which shows the rules of extended transformation. It converts 64-bit input data into 96-bit output data, uses the 64th bit of the input sequence as the first bit of the output sequence, and The first bit 怍 is the second bit of the output sequence, and so on; I 2 3 4 5 <b

6 7 8 9 8 9 10 11

12 13 12 13 M 15 16 17

16 17 18 19 20 21 20 21

22 23 24 26 H 26 26 27

28 29 28 29 30 31 32 33

32 33 "36 36 37 36 37

38 39 40 a 40 41 i2 43

"<7 iS"

60 61 62 63 62 63

56 57 & 6 67 58 69

60 61 60 61 62 63 Si 1

The secret box replacement is a compression replacement. Each secret box of the present invention has 16 secret tables, each of which is divided into 4 rows and 16 columns, and the input 96-bit data is divided into 16 groups in order. Group of ⁶ bits, each group of substitutions corresponds to a secret table in turn. In the 6-bit input data, the first ² bits form the row number, and the middle 4 bits form the column number. This row number and column number are in the appropriate secret. The element values are extracted from the table as output, and the output of each group is combined together in order to become the 64-bit output data replaced by the secret box;

The transformation E is a kind of scrambling, and it uses a pseudo-random number and another number to perform an exclusive OR operation. The number obtained is still a pseudo-random number.

2. The file encryption processing method according to claim 1, wherein the secret box replacement may include one secret box and 16 secret tables as shown in Table A and Table B below;

If any of the positions shown in exemplar cryptograms B I ⁶ Table 2 table is reversed to form a new secret cartridge; if the table, the table number of the same as shown in any column B 2 '1 The positions of the two are reversed at the same time (or the arrangement of any two columns with the same column number of the new box is reversed at the same time), then a new secret box is also formed, and so on. It can be known that the present invention proposes a Secret box group, a total of (16!) ² secret boxes; Column number

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 so row 0 15 1 5 6 10 9 4 12 8 11 2 7 3 0 13 14

1 6 5 15 10 9 4 1 2 0 7 13 12 11 14 8 3 No. 2 8 6 14 1 3 7 9 0 12 10 5 4 2 11 15 13

3 1 2 0 8 11 5 10 13 9 14 6 15 4 7 3 12

SI 10 2 7 8 4 6 15 5 9 0 1 13 14 12 3 11

15 6 2 9 12 3 0 8 7 5 11 10 4 13 14]

9 0 15 4 2 10 1 3 13 11 6 5 7 14 8 12

0 14 6 7 15】 3 9 10 8) 3 4 11 2 12 5

S2 14 10 8 7 3 5 2 6 15 9 0 4 12 11 1 13

7 4 1 8 15 0 5 10 3 6 12 11 9 2 13 14

1 7 6 12 5 9 11 8 10 2 14 τ, 4 13 0 15

10 15 2 0 12】 4 1]] 7 8 13 6 5 4 9 3

S3 13 0 10 5 9 8 14 3 11 1 15 12 6 7 2 4

8 7 0 1 11 15 4 9 5 13 10 14 3 12 6 2

2 1 5 3 4 11 12 7 15 9 13 10 8 0 14 6

11 5 4 2 3】 2 0) 4 6 15 8 13 10 9 7 1

S 7 9 6 4 2 13 5 11 12 10 14] 15 3 0 8

3 2 5 7] 4 1 8 0 6 4 15 9 13 10 11 12

10 15 4 2 7 12 0 5.] 4 8 9 n 6 1 13 3

9 6 15 5 13! 0 4 I 3 11 7 14 2 12 8 0

S5 3 11 9 2 8 12 13 4 7 5 10 6 1 15 14 0

9 8 6 3 10 14 7 1 4 2 0 15 12 11 5 13

11 14 7 0 1 13 10 2 5 6 9 15 4 3 8

8 7 14 4 0 11 3 15! 2 10 5 2 6 1 13 9

S6 8 4 15 9 5 10 3 1 2 12 13 0 11 14 7 6

5 14 9 12 8 11 6 π 1 10 4 7 2 0 3 15

14 10 3 13 12 8 5 6 11 4 7 15 9 2 1 0

4 3 10 15 1 9 11 12 5 2 14 8 13 6 0 7

S7 4 3 2 10 12 15 6 9 1 8 7 14 0 13 11 5

14 12 8 11 1 13 9 3 10 0 6 5 7 15 2 4

0 9 13 6 Π】 4 8 15 4 3 I 7 12 10 5 2

3 13 1 9 6 0 7 8 2 12 10 Π 14 5 A 15 Form A replacement page (Article 26) Column number

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 rows 0 6 5 14 0 15 11 8 7 10 13 12 2 4 1 9 3

1 0 11 7 6 3 5 14 12 15 9 2 13 1 4 10 8 No. 2 13 2 1 5 6 15 3 14 9 7 10 8 0 12 4 11

3 2 4 3 I 10 7 12 5 13 0 11 9 15 8 6 14

S9 0 13 12 11 6 7 1 8 14 3 9 15 2 5 4 10

11 3 14 5 2 12 10 4 13 1 8 6 15 9 0 7

5 8 0 14 10 6 15 9 3 12 2 1 13 7 1 I 4

13 0 11 10 14 4 8 2 1 9 12 7 3 15 5 6

S10 2 8 4 12 7 14 0 13 5 15 11 3 9 6 10 1

1 10 3 4 13 6 11 15 12 8 9 2 14 5 7 0

12 5 9 11 8 0 2 4 1 14 15 13] 0 3 6 7

7 9 12 3 5 15 13 0 10 6 4] 8 14 2 11

Sll 5 12 n 3 14 1 7 0 13 2 8 9 10 4 6 15

10 9 4 15 0 2 13 14 8 3 5 1 6 7 12 11

3 13 8 10 9 5 4 1 2 15 0 12 11 6 7 14

12 8 13! 1 2 6 5 9 4 7 15 0 1 3 14 10

SI2 12 15 0] 11 4 9 2 3 14 6 5 13 10 8 7

4 13 10 0 7 9 12 6 2 11 14 3 8 1 15 5

7 3 12 15 13 1 6 11 8 0 4 2] 4 5 9 10

15 1 9 6 4 8 14 3 11 5 2 12 7 0 10 13

S13 9 6] 15 13 2 10 14 0 4 3 11 7 8 5 12

2 0 11 13 6 10 15 7 14 12 1 8 5 3 4 9

15 11 2 7 0 4 13 10 6 1 8 14 3 9 12 5

5 12 8 14 7 3 6 4 15 13 0] 0 9 11 1 2

S14 1 7 13 14 0 3 11 15 4 6 5 10 8 2 12 9

13 15 12 2 5 8 3 11 9 14 7 4 0 6 1 10

6 4 11 9 15 2 14 12 7 13 3 0 5 8 10 1

14 11 7 13 8 1 2 6 0 3 9 5 12 10 15 4

S15 11 14 3 13 1 0 12 10 6 7 4 8 5 9 15 2

12 1 13 14 4 7 2 5 11 15 3 0 10 8 9 6

4 12 10 8 14 3 7 13 0 5 11 6 1 15 2 9

6 10 5 12 9 2 15 7 14 4 I 3 0 13 11 8 Table B

Replacement page (Article 26)

3. The file encryption processing method according to claim 1, wherein the pseudo-random number sequence is generated according to a formula:

x _{i> 2} = (x _; X _i ) MOD M when x ,. ₂ ≠ l

x _if2 = maximum prime less than M when x _w = l

Where M is a prime number and χ. ^ = 0, Μ; χ, ^ Ο, Ι, Μ; i = 0, l, —, (η-2), η is a natural number

4. The file encryption processing method according to claim ³ , wherein the 64-bit data obtained by substituting the secret box is used as an input of this process, and the 对 for transforming E can be:

First 4 bar 64 bit input data Nong Cibin to SX. (I = 0,7), 3

7

The length is one byte; let the variable S be one byte long, according to the formula 256, find i = 0

7

Out S; if SXi = 0, let SX. = 241, SX. = 239. Then search from the head of i = 0

Search for the first non-zero, non-251-valued byte. If found, use the byte as the first noise source. If it is not found, use 241 as the first noise source. Then start from the tail of SXi. Reverse search the first occurrence of non-zero, non-one, and non-251-valued bytes. If found, the byte is used as the second noise source. If it is not found, 239 is used as the second noise source. Let 8 be the number of loops, and let the variable i be 0, in the loop body. The first stage 搡怍 is to multiply the first noise source by the second noise source, divide its product by 251, to get the remainder R, and (R㊉ The value of S㊉ SX for the second stage is to use the second noise source of the current cycle as the first noise source of the next cycle, and use the remainder R as the second noise source of the next cycle. (If R = 1, then 239 as the second noise source). Then increase the variable i by 1. If the loop does not end, then return to the beginning of the loop body and perform the operation in the loop body. 7) Output as the result of the encryption function F;

The transformation of E can also be as follows: The 64-bit input data is sequentially assigned to SX, (i = 0,3), and the length of SX, is a word, corresponding to the operation of transformation E described above, and corresponding changes The place can be based on the following facts: U) In an unsigned integer, the maximum value of a byte is 255, and the maximum value of a word is 65535; (2) In the range of one byte, the prime number is from large to small The permutations are: 251, 241, 239, 233, and within a word range, the corresponding permutations are: 65521, 65519, 65497, 65479,

5. The file encryption processing method according to claim 1, wherein, when the source file determined by the user is read into the memory, a memory located at a high-end address can be applied to the operating system to place the source file and the target file.

6. A file encryption processing method and its floppy disk, characterized in that its application range is:

(1). The encrypted (or decrypted) command file (or executable file with the suffix "EXE" type) formed by this method can be written on a floppy disk or hard disk, or an instruction group with encryption function can be formed. Written on a read-only memory ROM or program read-only memory PRO ^;

(2). Such products are suitable for encryption (or decryption) of text files, image files, etc. They can also be used in real-time systems, including real-time communication of digital image signals or digital audio signals;

( ³ ). It applies to single-user operating system, or multi-user operating system, or small computer, or microcomputer.