Sequence Encryption Method for Reconstructed Secret Key

Abstract

The present invention discloses a sequence encryption method for complex reconstructed keys: a chaotic computing structure is constructed using a set of composite logics to achieve chaotic bit-stream sequence encryption. The present invention schedules computing logic units such as bit extraction logic, bit metabolism logic, and bit reconstruction logic through the chaotic computing structure, and pseudo-randomly reconstructs the source of construction and the source of control segment by segment to construct a regenerated key bit segment sequence of "pseudo-randomly misaligned extraction of the key bit segment source bits that have not been metabolized or re-extraction of the key bit segment source bits that have been metabolized". The core of the present invention is to construct a chaotic computing structure, metabolize the working pool segment by segment during the encryption process, and then use the bit bits in the control source to control the bit extraction logic to extract the bit bits in the construction source for the control source and the construction source carried by the working pool, and pseudo-randomly reconstruct and re-construct the key bit segments. The beneficial effects of the present invention are: adapting to the breakthrough improvement of computing power and providing a set of secure encryption methods with high efficiency, high density, and wide application space.

Description

Technical Field

[0001] The present invention relates to the field of information security cryptography, and is a sequence encryption method for complex reconstructed keys. Background Art

[0002] Chinese Patent Application No.: 201710249427.9 discloses a sequence encryption method for an adjoint random reconstructed key based on a random binary sequence and having adjustability. The main features of the method are: (1) Dynamically constructing a seed random sequence using an existing random sequence. (2) Pseudo-randomly constructing a random key using the seed random sequence in fixed-length or variable-length bit segments. (3) The pseudo-random construction process of the random key accompanies the encryption process. (4) Utilizing the transitivity of the exclusive OR operation to achieve frequency conversion non-linear exclusive OR of the key with the plaintext. (5) Adjusting the key construction by adjusting the characteristic quantity, other manipulation quantities, and the pseudo-random construction function, thereby realizing the adjustment of the encryption density without increasing the time complexity. (6) The characteristic quantity or other manipulation quantities used in this adjoint pseudo-random reconstructed key method cannot be inversely deduced within a polynomial time complexity. The basic principle of the method is: Utilizing the randomness of the random sequence to pseudo-randomly manipulate the encryption logic process, thereby realizing sufficient chaos and concealment of the key construction process, and blocking the parsing path of the ciphertext with a secret agreement implicitly agreed upon by the encryption / decryption parties. Summary of the Invention

[0003] The present invention discloses a method for implementing a chaotic computing structure by using a key and a structure configuration quantity to configure a structure manipulation quantity, and then performing chaotic bit segment stream sequence encryption with a composite logic supported by it.

[0004] The object of the present invention is achieved through the following concept: Based on a composite logic, a chaotic computing structure is constructed, and the plaintext is encrypted round by round (or segment by segment) in variable-length bit segments determined pseudo-randomly. During the encryption process, according to the configuration of the computing structure, a key bit segment construction source (or construction source) and a key bit segment manipulation source (or manipulation source) are pseudo-randomly reconstructed segment by segment, and the manipulation source is used to pseudo-randomly manipulate the construction source to reconstruct and regenerate key bit segments bit by bit round by round. Further, the regenerated key bit segment sequences generated segment by segment are integrated to perform infinite non-cyclic bit segment stream sequence encryption. The key to achieving the conceptual goal is: Scheduling the bit extraction logic, bit metabolism logic, and bit reconstruction logic (including pseudo-random bit rearrangement logic and pseudo-random bit conversion logic, see the description of several key points) to reconstruct a regenerated key bit segment sequence of 'pseudo-randomly misplacing and extracting the construction source bits not metabolized or re-extracting the construction source bits that have been metabolized', and then: (1) Using the chaotic computing structure to eliminate the periodic rate of the regenerated key bit segment sequence generated from a finite set, (2) Realizing the entanglement between regenerated key bit segment sequences and embedding pseudo-random bit entanglement by superimposing misaligned segments of more than one regenerated key bit segment sequence. The technical solutions include:

[0005] (1) Construct a chaotic computing structure from the key through the structural configuration quantity to support the bit-by-bit segment sequence encryption that pseudo-randomly determines each segment of computing parameters.

[0006] (2) Load the initial working pool with the key to lead the chaotic encryption process of bit-by-bit segment logical entanglement.

[0007] (3) Use the pseudo-plaintext extended working pool independently constructed by the encrypting party to further the chaotic encryption process and increase the safety valve threshold.

[0008] (4) Establish a mechanism for the sequential metabolism of the working pool, and configure the bit extraction logic and bit metabolism logic accordingly. Establish a logic for constructing the regenerated key bit segment that "pseudo-randomly misplaces and extracts the unmetabolized construction source bit or re-extracts the metabolized construction source bit".

[0009] (5) Use the chaotic computing structure to eliminate the periodic law that may appear in the constructed regenerated key bit segment sequence.

[0010] (6) Use different construction sources, control sources, bit extraction logics, and bit metabolism logics to construct different regenerated key bit segment sequences, and implement the misaligned superposition encryption of the embedded pseudo-random bit entanglement of different regenerated key bit segment sequences based on the chaotic computing structure.

[0011] (7) Based on the key, establish a plaintext end symbol to resolve the misalignment between the plaintext end position and the computing end position, and use the plaintext end symbol as the verification code for the correctness of the decryption calculation.

[0012] In the present invention, according to the structural configuration quantity and the key secretly agreed upon by the encryption / decryption parties, the initial value of the dynamically driven vector, the maximum / minimum limit of the bit segment length, the size of the key bit segment selection pool (or selection pool), the size of the pseudo-plaintext random string, and other computing structure control quantities (or structural control quantities) are pseudo-randomly determined. The construction source and control source in the selection pool, the encryption bit segment length, etc. are pseudo-randomly updated round by round to construct a chaotic regenerated key bit segment sequence, and further, the chaotic effect is amplified exponentially through the misaligned superposition logic structure, and the infinite non-cyclic bit segment stream encryption (bit-segment stream encryption) based on the regenerated key bit segment sequence is integrated.

[0013] The beneficial effect of the present invention is to provide a secure encryption method that is efficient, high-density, and has a wide application space to adapt to the breakthrough improvement of computing power.

[0014] Explanation of several key points

[0015] The present invention uses a concept called chaotic computing structure in this specification: during the encryption process, pseudo-randomly varying computing parameters are used to create chaos in the encryption computing trajectory, forcing the attacker to face a chaotic computing form. The uncertainty of the chaotic computing structure driven by the key provides a broad logical integration space for the encryption of bit-stream sequences. Based on the pseudo-random variation of the chaotic trajectories of encryption / decryption based on logical integration, both the encryption and decryption parties can control it, but the attacker faces a chaotic trajectory form. The chaotic computing form generated by the chaotic computing structure of the present invention includes the following aspects: the pseudo-random variation of the structure control quantities generated using different keys, the pseudo-random variation of the computing parameters regenerated segment by segment by the structure control quantities during the encryption process, and the pseudo-random variation of the integration form of the encryption logic unit (input / output and its matching effect of bit-taking logic, bit-metabolism logic, and bit-reconstruction logic), the construction form of the regenerated key bit segments (length and construction rules), and the integration form of the regenerated key bit segments (segment misalignment superposition and embedding of pseudo-random bit-bit entanglement) driven by the computing parameters during the encryption process.

[0016] The present invention uses a selection pool as the carrier of the construction source and the control source, and the content of the selection pool is replaced segment by segment during the encryption process. Only part of the content of the selection pool is valid at the beginning of encryption, which is called the key bit segment working pool (or working pool) in this specification. The working pool expands segment by segment with the reconstruction of the regenerated key bit segments until it fills the selection pool, and this stage is called the growth period of the working pool in this specification. After passing through the growth period, the working pool reaches maturity, and the working pool still changes with the reconstruction of the regenerated key bit segments during the maturity period. This specification collectively refers to the growth during the growth period of the working pool and the change during the maturity period as the metabolism (or metabolism) of the working pool (or selection pool).

[0017] The present invention adds a pseudo-plaintext random string (or pseudo-plaintext) that has nothing to do with the content of the plaintext before the plaintext. The pseudo-plaintext has the following characteristics: (1) Since the random string is not recognizable, it is impossible to distinguish whether the attack on the pseudo-plaintext is successful. During the growth period of the working pool, the pseudo-plaintext is embedded in the working pool segment by segment, and after the working pool reaches maturity, the pseudo-plaintext has the same effect as the key. (2) The pseudo-plaintext is not a key, but a random string independently constructed by the encryption party to expand the working pool during the growth period, and is regarded as a waste code after decryption. (3) The pseudo-plaintext has the effect of further chaotic computing process during the encryption process. Different pseudo-plaintexts lead to differences in the construction source and control source when encrypting the official plaintext, and further lead to differences in the regenerated key bit segment sequences.

[0018] In 'pseudo-random misaligned extraction of unmetabolized construction source bit bits or repeated extraction of metabolized construction source bit bits','misaligned extraction' refers to bit bits with different extraction positions in different extractions, and'repeated extraction' refers to bit bits with the same extraction position in different extractions.

[0019] The bit retrieval logic and the bit metabolism logic are important constituent logic units for realizing 'pseudo-random misalignment extraction of unmetabolized structural source bits or re-alignment extraction of metabolized structural source bits'. Their integration effect is indispensable to the infinite non-circular system of the present invention. The composite logic structure of the present invention needs to accommodate more than one bit retrieval logic and bit metabolism logic. Different bit retrieval logics and bit metabolism logics can be integrated into computing models of different combinations. The misaligned superposition logic structure composed of different bit retrieval logics and bit metabolism logics can improve the security of the present invention exponentially. The bit picking logic presented in this specification includes key bit segment progressive picking logic (or progressive picking logic), key bit segment progressive chain picking logic (or progressive chain picking logic), key bit segment bit jump picking logic (or bit jump picking logic), and key bit segment extended bit picking logic (or extended bit picking logic). The bit metabolism logic presented in this specification includes key bit segment selection pool extended bit metabolism logic (or extended bit metabolism logic) and key bit segment selection pool extracted bit metabolism logic (or extracted bit metabolism logic). The composite logic structure of the present invention can also accommodate other bit picking logic and bit metabolism logic.

[0020] Following the principle of 'pseudo-randomly dislocating and extracting unmetabolized source bits or re-locating and extracting metabolized source bits', the present invention allows pseudo-random bit rearrangement to generate regenerated key bit segments after extracting the bits string. This specification refers to this as pseudo-random bit rearrangement. The present invention also requires that the original metabolic source pseudo-random string (i.e., the output pseudo-random string output by the bit-taking logic before generating the regenerated key bit segment, the same below) be (1) pseudo-randomly rearranged before the working pool is metabolized, and (2) the bit value is inverted bit by bit (0 to 1 or 1 to 0, or so-called (3) adding sugar. This specification will rearrange the pseudo-random bits of the original metabolic source pseudo-random string, Interchange and sugaring are collectively called pseudo-random bit conversion (See the relationship between bit retrieval logic and bit metabolism logic for details).

[0021] The present invention uses a dynamic driving vector that runs through the entire computing process. The dynamic driving vector is replaced (or metabolized) round by round. The initial value of the dynamic driving vector used in this specification is pseudo-randomly generated by a key. The present invention is still feasible if this initial value is changed to an initial value secretly agreed upon by the encryption / decryption parties rather than generated by a key. This does not involve the structure of the encryption operation and is not further explained in this specification.

[0022] Due to the pseudo-random variation of the bit segment length in the encryption process, it is highly probable that the end position of the segmented calculation is misaligned with the end position of the plaintext. The present invention uses a plaintext end symbol constructed pseudo-randomly by a key to calibrate the end position of the plaintext and eliminates the above misalignment effect by appending a pseudo-random string. Since the layers of winding in the encryption / decryption process of the present invention have a conduction effect, any encryption / decryption error will continue to the subsequent calculations, resulting in the inability to obtain the plaintext end symbol during encryption, transmission, and decryption. Therefore, the plaintext end symbol also has the function of a check code.

[0023] To clearly describe the composite logic structure of the present invention, this specification splits the description of the sequence encryption method for reconstructing the key into three logic components for explanation: (1) a single reconstructed logic structure, (2) the integration of bit extraction logic and bit metabolism logic, and (3) a misaligned segment superposition logic structure.

[0024] The core of the present invention: (A) Construct a chaotic computing structure, metabolize the working pool segment by segment in the encryption process, and then use the bit positions in the control source to control the bit extraction logic to extract the bit positions in the construction source from the control source and the construction source carried by the working pool, and pseudo-randomly reconstruct and regenerate the key bit segments. (B) Based on the chaotic computing structure, integrate the bit extraction logic and the bit metabolism logic to construct an infinite non-repeating construction logic for the regenerated key bit segments that "pseudo-randomly misalign and extract the bit positions of the unmetabolized construction source or re-extract the bit positions of the metabolized construction source". (C) Based on the chaotic computing structure, perform misaligned segment superposition encryption on more than one different regenerated key bit segment sequences.

[0025] The chaotic computing structure expands the effect of "pseudo-randomly misaligning and extracting the bit positions of the unmetabolized construction source or re-extracting the bit positions of the metabolized construction source". Only by understanding the basic operating principle of "pseudo-randomly misaligning and extracting the bit positions of the unmetabolized construction source or re-extracting the bit positions of the metabolized construction source" can one see the expansion effect of the chaotic computing structure. Therefore, this specification inserts the description of the expansion effect of the chaotic computing structure after explaining the integration of the bit extraction logic and the bit metabolism logic.

[0026] As an embodiment of the present invention, this specification selects the non-superposition & single metabolism model configured with progressive carry logic / sequential bit extraction metabolism logic as Example 1, and the double superposition & double metabolism misaligned segment superposition model configured with progressive chain bit extraction logic / sequential bit extraction metabolism logic and bit jump bit extraction logic / extracted bit metabolism logic as Example 2. Other combined models are not excluded.

[0027] Some logic units (or logic steps) of the present invention can be omitted or not omitted, and the omission or non-omission is determined according to different logic combinations (such as pseudo-random bit rearrangement (which can be selected according to different situations), and will be shown in the figures of this specification in an unabridged form except in specific situations. Since such a logic unit is still part of the logical structure, showing it is conducive to seeing the logical relationships clearly.

[0028] There are three ways to represent the position chain in this specification: (1) pos_chain, (2) pos_chain(j), j = 0, 1, 2,... L max -L min , (3) pos_chain(j, k), j = 0, 1, 2,... L max -L min , k = 0, 1, 2,..., L min +j - 1. Among them, (1) is used generally for the position chain set, (2) is used for the set composed of each position chain, and (3) is used for the position element set. In addition, pos_chain(j) specifically refers to a certain position chain marked by j, and pos_chain(j, k) specifically refers to a certain position element marked by j and k. In the position chain expression of the error segment superposition logic structure with embedded pseudo-random bit wrapping in this specification, a special description form - position chain pos_chain(r), r = 0, 1,..., 2s - 2 is adopted. Here, r does not refer to the position chain serial number in the position chain set pos_chain(j), j = 0, 1, 2,... L max -L min but refers to the position chain used for the r-th metabolism in the 2s - 1 repeated metabolisms of the ls i -L min -th position chain pos_chain(ls i -L min ). See the notes on 4.5.3.2 and 4.5.4.4 in the error segment superposition logic structure for details. i -L min )(See the notes on 4.5.3.2 and 4.5.4.4 in the error segment superposition logic structure).

[0029] In the description part (before the embodiments) of this specification, a unified catalog numbering is adopted (such as 4.5.3.2 above). For each embodiment, a new catalog numbering is adopted according to the described theme. Among them, except for the catalog numbering marked with the theme prefix (such as: 'The encryption / decryption calculation formula and calculation unit 7 of Embodiment 1'), the catalog numbering in the narrative text of other embodiments refers to the catalog numbering of the current theme (such as: 'Repeat steps 11 to 19...' in Decryption 20 in the encryption / decryption process control of Embodiment 2 refers to steps 11 to 19 of Decryption in Embodiment 2).

[0030] This specification is described with feasible but not exclusive calculation formulas and calculation parameters, and does not exclude other equivalent configurations that follow the inventive concept of the present invention. It can be understood that equivalent replacement, modification or simplification of the technical solutions and inventive concepts of the present invention should fall within the protection scope of the appended claims of the present invention. Description of the Drawings

[0031] Figure 1 It is a schematic diagram of the principle of a single complex reconstruction logic structure.

[0032] Figure 2 It is a schematic diagram of the cooperative working principle of carry-taking logic and sequential carry-raising metabolism logic.

[0033] Figure 3 It is a schematic diagram of the cooperative working principle of progressive chain bit-taking logic and the bit metabolism logic of the extracted bit.

[0034] Figure 4 It is a schematic diagram of the cooperative working principle of bit-jumping bit-taking logic and the bit metabolism logic of the extracted bit.

[0035] Figure 5 It is a schematic diagram of the effect of sequential carry-raising metabolism.

[0036] Figure 6 It is a schematic diagram of the effect of the bit metabolism of the extracted bit.

[0037] Figure 7 It is a schematic diagram of the principle of a simple misaligned segment superposition logic structure.

[0038] Figure 8 It is a schematic diagram of the principle of a misaligned segment superposition logic structure with embedded pseudo-random bit wrapping.

[0039] Figure 8 ’ It is a schematic diagram of the calculation process of the misaligned segment superposition logic with embedded pseudo-random bit wrapping.

[0040] Figure 9 For Figure 8 It is a schematic diagram of a misaligned segment superposition logic structure with embedded pseudo-random bit wrapping at a different embedding position.

[0041] Description of the sequence encryption method of the complex reconstruction key

[0042] In the present invention, the composite logic structure is the basis for realizing the regenerated key bit segment sequence to be reconstructed and its integration. To clearly describe the composite logic structure of the present invention, this specification divides the composite logic structure into three logical components (a single reconstruction logic structure, the integration of bit extraction logic and bit metabolism logic, and a misaligned segment superposition logic structure) for description. Since the effect of the chaotic computing structure in eliminating the periodic rate of the regenerated key bit segment sequence is based on the integration of bit extraction logic and bit metabolism logic, after elaborating on the integration of bit extraction logic and bit metabolism logic, the expansion of the effect of the chaotic computing structure on 'pseudo-randomly misaligned extraction of unmetabolized source bits of the key bit segment or re-extraction of source bits of the key bit segment that have been metabolized' is inserted. The misaligned segment superposition logic structure is the composite effect of the chaotic computing structure of the present invention, achieving the goal of the inventive concept.

[0043] 1 Single reconstruction logic structure

[0044] The single reconstruction logic structure realizes the process of pseudo-randomly scheduling and reconstructing the regenerated key bit segment sequence by the key: in the preprocessing at the beginning of encryption / decryption, the present invention uses the structure configuration quantity secretly agreed upon by both the encryption and decryption parties in combination with the key configuration structure control quantity to support the pseudo-random reconstruction calculation parameters segment by segment by the structure control quantity during the encryption / decryption process, and implements the control of each logic unit. During the encryption / decryption process, based on this control, the chaotic computing structure realized collaborates with the bit extraction logic and bit metabolism logic to jointly support the operation of 'pseudo-randomly misaligned extraction of unmetabolized source bits of the key bit segment or re-extraction of source bits of the key bit segment that have been metabolized'.

[0045] Combined with the appendix Figure 1 Introduce the correlation relationship of each computing unit in constructing the regenerated key bit segment sequence of the present invention:

[0046] 1.1 Figure 1 Show the encryption process. Since the decryption process only has non-structural differences from the encryption process in (1) preprocessing and postprocessing, and (2) the metabolic source during the growth period of the working pool, the decryption process will not be elaborated here and will only be described when necessary.

[0047] 1.2 Figure 1 In represents a computing unit identified by Pnnn, rvnnn represents the output of a Pnnn, Specifically represents bit extraction logic or bit metabolism logic, s001 represents the encryption object, ← represents the structure control quantity (such as rV002), control source (such as key) of the indicated computing unit, ← represents the connection relationship between computing units, Specifically refers to a pseudo-random bit rearrangement, Specifically refers to a pseudo-random bit conversion, Specifically, perform pseudo-random bit conversion using the original metabolic source pseudo-random string

[0048] 1.3 Configure the structure control quantity pseudo-randomly through the structure configuration quantity and key secretly agreed upon by both the encryption and decryption parties. For example, the maximum value of the bit segment length (Max length of bit segment, or L max ) and the minimum value of the bit segment length (Min length of bit segment, or L min ) P002 , the length of the selected pool (Source pool, or Spool) marked as rV002 and the initial length of the working pool (Source work pool, or Spool work ), P003 , the initial value (vector0) of the dynamic drive vector marked as rV003 P004 , the end-of-plaintext (End-Of-Plaintext, or EOP) marked as rV004 P005 , and the initial position chain set pos_chain, etc.

[0049] 1.4 Configure the chaotic computing structure and preprocessing using the structure configuration quantity:

[0050] 1.4.1 Configure the length of the selected pool Spool, the length of the initial working pool Spool init according to the structure configuration quantity ctl work , and load the initial content of the working pool Spool work with the key.

[0051] 1.4.2 Generate the pseudo-plaintext (pseudoplaintext, or pM) marked as rV005 proportionally according to the length of the selected pool Spool P006 .

[0052] 1.4.3 Concatenate the pseudo-plaintext pseudo plaintext, plaintext, end-of-plaintext EOP, and append the padding pseudo-random string ms max with length L additn to reconstruct the encrypted plaintext P007 s001 (rebuild plaintext, or plaintext M or encrypted plaintext M).

[0053] 1.4.4 Calculate the lengths of the first-round regenerated key bit segment, plaintext bit segment, and ciphertext bit segment (collectively referred to as bit segment length ls i , or lsi ) and determine the initial positions of the construction source and the control source in the working pool according to the selected bit extraction logic m001, determine the initial metabolic target area in the selection pool according to the selected bit metabolism logic m002, and reconstruct other calculation parameters. P008

[0054] 1.5 Reconstruct and regenerate the key bit segment and perform encryption calculation

[0055] 1.5.1 Use ls calculated from rV001 i Based on the previous plaintext bit segment M i-1 Sequentially extract the encrypted plaintext bit segment.

[0056] 1.5.2 From the working pool (Spool work ) according to ls calculated from rV001 i Use the bit extraction logic m001 to pseudo-randomly extract and output a pseudo-random string.

[0057] 1.5.3 For the output pseudo-random string obtained in 1.5.2, perform (or not perform) pseudo-random bit rearrangement with an equal-length position chain pos_chain(ls i -L min ) (for example: sequentially splice the bit values of the output pseudo-random string specified by the position elements in the position chain) to obtain the current round of regenerated key bit segment . bsk i .

[0058] 1.5.4 Use the regenerated key bit segment bsk i to perform exclusive OR calculation on the plaintext bit segment M i . P009 .

[0059] 1.5.5 Working pool metabolism

[0060] 1.5.5.1 Metabolism during the growth period of the working pool (length(Spool work ) < length(Spool))

[0061] During encryption, append the pseudo-plaintext bit segment pM i with a length equal to ls i to the end of the working pool in sequence or insert it into the working pool bit by bit pseudo-randomly until the working pool reaches maturity.

[0062] During decryption, append the pseudo-plaintext bit segment pM i with a length equal to ls i to the end of the working pool in sequence or insert it into the working pool bit by bit pseudo-randomly until the working pool reaches maturity.

[0063] (Note: The length of the last calculation segment in the growth period is most likely greater than the length of the remaining pseudo - plaintext substring. In this case, only append the remaining pseudo - plaintext substring to the end of the working pool or insert it bit - by - bit pseudo - randomly into the working pool. See 2.6)

[0064] 1.5.5.2 Maturity of the working pool (length(Spool work ) = length(Spool)) Metabolism

[0065] 1.5.5.2.1 Pseudo - random bit - conversion of the original metabolic source pseudo - random string ( Figure 1 output of m001 in) with an equi - length position chain pos_chain(ls i -L min ) (The pseudo - random rearrangement therein must be different from 1.5.3. For example: perform metabolism on the position chain pos_chain(ls i -L min ) before the pseudo - random bit - rearrangement to generate the metabolic source pseudo - random string.)

[0066] 1.5.5.2.2 Use the metabolic source pseudo - random string obtained in 1.5.5.2.1 and the bit - metabolism logic m002 to perform metabolism on the working pool Spool work

[0067] 1.6 i = i + 1, pseudo - randomly reset the calculation parameters for the next segment of complex reconstruction encryption P010，P011 , and perform the next - segment encryption (loop and execute 1.5) until the length of the remaining unencrypted plaintext is less than or equal to the maximum value L of the segment length limit max .

[0068] 1.7 Post - processing P012

[0069] 1.7.1 When encrypting, splice the remaining bits string after the calculation end - bit of the plaintext to the ciphertext.

[0070] 1.7.2 When decrypting, clear the pseudo - plaintext pM, the plaintext end - of - packet EOP, and the padding pseudo - random string ms additn .

[0071] 2 Integration of bit - extraction logic and bit - metabolism logic

[0072] The integration of bit - extraction logic and bit - metabolism logic includes the associated manipulation between bit - extraction logic and bit - metabolism logic, and the bit - reconstruction logic (including pseudo - random bit - rearrangement logic and pseudo - random bit - conversion logic) that supports this associated manipulation, the metabolism and initialization of the position chain pos_chain, and the dynamic drive vector vector​i metabolism

[0073] To represent the correlation between bit extraction logic and bit metabolism logic, Figure 2 and Figure 3 and Figure 4 both stagger and display the two.

[0074] The bit extraction logic and bit metabolism logic are regulated by the chaotic computing structure. The chaotic computing structure, bit extraction logic, and bit metabolism logic jointly support the infinite non-cyclic operation of 'pseudo-randomly misaligned extraction of unmetabolized construction source bit positions or re-extraction of metabolized construction source bit positions with duplicate bits'.

[0075] bit extraction logic

[0076] 2.1 Progressive carry logic

[0077] Combined with the attached Figure 2 introduce the progressive carry logic:

[0078] 2.1.1 Figure 2 What is shown is the progressive carry logic of the i-th regeneration key bit segment (the first row) and the (i + 1)-th regeneration key bit segment (the third row), Figure 2

[0079] and also shows the sequential bit extraction and metabolism logic of the i-th round (the second row) and the (i + 1)-th round (the fourth row) implemented in an interleaved manner with the progressive carry logic. The starting byte C of the construction source of the (i + 1)-th regeneration key bit segment is shifted by one byte along with the starting byte C of the construction source of the i-th regeneration key bit segment (continuing from the head after reaching the end of the working pool).

[0080] In each round of calculation, the starting construction byte C serves as the first construction byte pickstart i,0 and the ls i bytes starting from it ( the belonging byte, continuing from the head when reaching the end of the working pool) serve as the construction source pickarea i (C to D). The position at a certain length from C serves as the first construction control bit pickdrivstart i,0 (E), and the bits substring composed of n (n can be selected as 3 or 4 or 8) times the ls i starting from it serves as the control source pickdrivearea i (continuing from the head when reaching the end of the working pool), obtaining ls i control elements (3 or 4 or 8 bits).

[0081] 2.1.3 Extract the values of 3 bits of the determined position or pseudo-random position from each control element as the control value, and obtain the control value sequence pickdriver i (j) (j = 0, 1, 2,..., ls i -1).

[0082] 2.1.4 Sequentially pair the control values in the control value sequence with the bytes in the construction source to obtain the control value / construction byte pair sequence pickdriver i (j) / pickarea i (j) (j = 0, 1, 2,..., ls i -1).

[0083] 2.1.5 Sequentially extract the values of the bits in the construction bytes specified by the control value from the control value / construction byte pair sequence pickdriver i (j) / pickarea i (j) (j = 0, 1, 2,..., ls i -1) and splice and output the pseudo-random string tmp_str(j) (j = 0, 1, 2,..., ls i -1).

[0084] 2.1.6 According to 1.5.3 of the single complex reconstruction logic structure, perform (or not perform) pseudo-random bit rearrangement on the above output pseudo-random string tmp_str(j) (j = 0, 1, 2,..., ls i to obtain the regenerated key bit segment bsk i .

[0085] 2.2 Progressive chain bit-taking logic (go chain logic)

[0086] The difference between the progressive chain bit-taking logic and the progressive carry bit-taking logic is that the order of the sequentially arranged byte segments in the construction source is changed to the order arranged by the position elements in the position chain.

[0087] Combined with Appendix Figure 3 Introduce the progressive chain bit-taking logic:

[0088] 2.2.1 Construct L max -L min +1 position chains pos_chain(j) with lengths ranging from L min to L max in the single complex reconstruction logic structure 3 (after P005), j = 0, 1,..., L max -L min (For example Figure 3 ​The shown Set of pos_chain) and initialize it to L max -L min +1 pseudo-randomly permuted position chains pos_chain(j) (j = 0, 1, 2, ..., L max -L min ), (see 5.2 for details).

[0089] 2.2.2 Figure 3 What is shown is the progressive chain bit-taking logic for the i-th regeneration key bit segment (top row) and the i + 1-th regeneration key bit segment (third row), Figure 3 and also shows the bit metabolism logic of the i-th round (second row) and the i + 1-th round (fourth row) implemented interleaved with the progressive chain bit-taking logic. The starting byte C of the construction source of the i + 1-th regeneration key bit segment is shifted by one byte along the starting byte C of the construction source of the i-th regeneration key bit segment (continuing from the head after reaching the end of the working pool).

[0090] 2.2.3 Establish the control source pickdrivearea i and the construction source pickarea i , and the control value sequence pickdriver i (j) (j = 0, 1, 2, ..., ls i -1).

[0091] 2.2.4 Sequentially match the position elements in the position chain pos_chain(ls i -L min ) with the control values in the control value sequence, and then achieve the matching between the control value / construction byte through the construction byte position in the construction source specified by the position element, obtaining the control value / construction byte matching pairs pickdriver i (j) / pickarea i (pos_chain(ls i -L min ,j)) (j = 0, 1, 2, ..., ls i -1).

[0092] 2.2.5 Sequentially extract the values of the bits of the construction bytes specified by the control value from the control value / construction byte matching pairs pickdriver i (j) / pickarea i (pos_chain(ls i -L min ,j)) (j = 0, 1, 2, ..., ls i -1) and splice and output the pseudo-random string tmp_str(j) (j = 0, 1, 2, …, lsi -1).

[0093] 2.2.6 According to 1.5.3 of the single complex reconstruction logic structure, perform (or not perform) pseudo-random bit rearrangement on the output pseudo-random string tmp_str(j) (j = 0, 1, 2,..., ls i -1) to obtain the regenerated key bit segment to obtain the regenerated key bit segment bsk i .

[0094] 2.3 Bit jump logic combined with the appendix Figure 4 Introduce the bit jump logic:

[0095] 2.3.0 For clear display, Figure 4 the ranges of the construction source and the control source are compressed and segmented in . After clarifying the logical relationship, expand the ranges of both to the entire working pool.

[0096] 2.3.1 Figure 4 The figure shows the bit jump logic diagram of the i-th regenerated key bit segment (top row) and the (i + 1)-th regenerated key bit segment (second row), Figure 4 and also shows the bit metabolism logic of the i-th round (top row) and the (i + 1)-th round (second row) interleaved with the bit jump logic.

[0097] 2.3.2 Determine the construction source pickarea i and the control source pickdrivearea i : The construction source pickarea i is composed of the bits string from the construction source start bit pickstart i,0 to the end of the selection pool and the bits string from the start of the selection pool to before the construction source start bit pickstart i,0 . The start bit pickstart of each round of the construction source i,0 is pseudo-randomly determined by the dynamic drive vector vector i (for example, taking the modulus according to the value expressed by the dynamic drive vector vector i with the working pool length length(Spool work ). The control source pickdrivearea i is composed of the bits string from the control source start bit pickdrivstart i,0 to the end of the selection pool and the bits string from the start of the selection pool to before the control source start bit pickdrivstart i,0 . The start position pickdrivstart of each round of the control source i,0 is the same as the start position pickstart of the construction sourcei,0 with a fixed or pseudo-randomly determined relative bit difference dif (0 < dif ≤ length(Spool work )): pickdrivstart i,0 = (pickstart i,0 + length(Spool work ) - dif) % length(Spool work ).

[0098] 2.3.3 Starting from the manipulation source starting bit pickdrivstart i,0 sequentially or pseudo-randomly jump to extract ls i bit strings of a determined length to form a bit jump value sequence junp_num(j) (j = 0, 1, 2,..., ls i - 1) (continuing from the head after reaching the end of the working pool).

[0099] 2.3.4 According to the bit jump value sequence junp_num(j) (j = 0, 1, 2,..., ls i - 1), starting from the construction source starting bit pickstart i,0 in the construction source, determine the construction bit bits by jumping one jump value junp_num(j) at a time (continuing from the head after reaching the end of the construction source), and extract its value and splice it to output a pseudo-random string tmp_str(j) (j = 0, 1, 2,..., ls i - 1).

[0100] 2.3.5 Use the constructed output pseudo-random string tmp_str(j) (j = 0, 1, 2,..., ls i - 1) and perform (or not perform) pseudo-random bit rearrangement as the regenerated key bit segment bsk i .

[0101] 2.4 Raise bit logic

[0102] The characteristic of the raise bit logic is that there are no unextracted bit bits in the rotation cycle of the construction source (i.e., the repetition cycle when the construction source progresses byte by byte in the working pool), so the utilization rate of the working pool by the regenerated key bit segment sequence is higher.

[0103] 2.4.1 The first-round construction source starting byte pickstart0 is pseudo-randomly determined by the initial dynamic drive vector vector0. Subsequently, the construction source starting byte pickstart i is sequentially postponed by one byte (continuing from the head after reaching the end of the working pool) pickstart i=(pickstart i-1 +8)% length(Spool work ).

[0104] 2.4.2 Construction source pickarea in each round i Consists of ls i bytes starting from the starting byte pickstart i of the construction source (continuing from the end of the working pool to the beginning when reaching the end).

[0105] 2.4.3 Let the extracted bit of the first construction byte in the above construction source pickarea i be the first bit of the byte, and then increase one bit for each subsequent byte (starting from 0 after reaching 7) as the extracted bit of each construction byte, and splice their values to output the pseudo-random string tmp_str(j) (j = 0, 1, 2,..., ls i -1).

[0106] 2.4.4 Use the constructed output pseudo-random string tmp_str(j) (j = 0, 1, 2,..., ls i -1) and perform (or not perform) pseudo-random bit rearrangement as the regenerated key bit segment bsk i .

[0107] Bit metabolism logic

[0108] Bit metabolism logic is one of the keys to implementing the present invention. This specification introduces two types of bit metabolism logic: sequential bit-raising metabolism logic and extracted bit metabolism logic. Around the composite logic structure of the present invention, there are several other metabolism logics related to bit metabolism logic that need to be explained: working pool bit metabolism during the growth period, dynamic drive vector i metabolism, and position chain pos_chain metabolism.

[0109] 2.4 Sequential bit-raising metabolism logic

[0110] The characteristic of the sequential bit-raising metabolism logic is that there are no unmetabolized bit positions in the rotation cycle of the metabolism target area (i.e., the repetition cycle when the metabolism target area progresses byte by byte in the working pool), so the coverage rate of the working pool for the set of natural numbers is higher.

[0111] Combined with Appendix Figure 2 , Appendix Figure 5 introduce the sequential bit-raising metabolism logic:[[]]

[0112] 2.4.1 As Figure 2As shown, perform pseudo-random bit conversion on the original metabolic source pseudo-random string (i.e., the output pseudo-random string tmp_str(j) extracted from the working pool by bit-taking logic, where j = 0, 1, 2,..., ls i -1). Obtain the metabolic source pseudo-random string metabolsrc i (j) (j = 0, 1, 2,..., ls i -1).

[0113] 2.4.2 As Figure 2 shown, select the byte that overlaps with the starting position E of the manipulation source (without excluding other bytes) as the starting byte metabolstart of the subsequent bit-lifting metabolic target area i .

[0114] 2.4.3 As Figure 2 shown, use the byte segment (E ~ F) composed of ls i bytes starting from the starting byte metabolstart i (E) as the subsequent bit-lifting metabolic target area metabolarea i . That is, all the calibrated bytes in the figure

[0115] 2.4.4 As Figure 5 shown in , set the metabolic bit of the first byte in the subsequent bit-lifting metabolic target area metabolarea i as the first bit of the first byte, and then increase the bit by one for each subsequent byte (continuing from 0 after reaching 7) as the metabolic bit of each byte in the subsequent bit-lifting target area, obtaining the metabolic bit sequence metabolbit i (j) (j = 0, 1, 2,..., ls i -1).

[0116] 2.4.5 As Figure 5 shown in , replace the value of each bit of the metabolic bit of each byte in the subsequent bit-lifting target area with the value of each bit of the metabolic source pseudo-random string metabolsrc i (j) (j = 0, 1, 2,…, ls i -1), metabolbit i (j) = metabolsrc i (j) (j = 0, 1, 2,..., ls i -1).

[0117] 2.5 Matched Bit Metabolic Logic

[0118] Combined with the attached Figure 4 Introduce the matched bit metabolic logic:

[0119] As Figure 4 shown in the matched bit metabolic logic, the picked bits overlap with the metabolic bits

[0120] 2.5.1 When constructing the output pseudo-random string tmp_str(j) (j = 0, 1, 2,..., ls i -1) for any bit extraction logic, retain each picked bit as the picked bit sequence pickedbit i (j) (j = 0, 1, 2,..., ls i -1).

[0121] 2.5.2 Use the position chain pos_chain(ls i -L min , j) (j = 0, 1, 2,..., ls i -1) to perform pseudo-random bit conversion on the original metabolic source pseudo-random string to obtain the metabolic source pseudo-random string metabolsrc i (j) (j = 0, 1, 2,..., ls i -1).

[0122] 2.5.3 One by one, use the metabolic source pseudo-random string metabolsrc i (j) (j = 0, 1, 2,..., ls i -1) to metabolize the picked bit sequence pickedbit i (j) (j = 0, 1, 2,..., ls i -1), so that pickedbit i (j) = metabolsrc i (j) (j = 0, 1, 2,..., ls i -1).

[0123] 2.6 Bit Metabolism of the Working Pool in the Growth Stage

[0124] 2.6.1 During encryption, in order, use the pseudo-plaintext bit segment pM i generated by the encrypting party with a length equal to or less than ls i (when the remaining pseudo-plaintext length in sequence is greater than or equal to ls i , take pM i = ls i ​; when the remaining length of the plaintext in sequence is less than ls i take pM i = the remaining length of the plaintext. Append it to the end of the working pool or pseudo-randomly insert it bit by bit into the working pool. And increase the length of the working pool length(Spool work ) = length(Spool work ) + length(pM i ).

[0125] 2.6.2 During decryption, for the plaintext bit segment pM i with a length equal to or less than ls i (when the remaining length of the plaintext in sequence is greater than or equal to ls i take pM i = ls i ; when the remaining length of the plaintext in sequence is less than ls i take pM i = the remaining length of the plaintext. Append it to the end of the working pool or pseudo-randomly insert it bit by bit into the working pool. At the same time, increase the length of the working pool length(Spool work ) = length(Spool work ) + length(pM i ).

[0126] Note: In 2.6.1 and 2.6.2, the pseudo-random algorithm for pseudo-randomly inserting the plaintext bit segment pM i bit by bit into the working pool can be arbitrary, because both the key and the plaintext are random strings and do not have recognizability.

[0127] 2.7 Position chain (pos_chain) metabolism

[0128] There are multiple feasible methods for position chain metabolism. This specification introduces a method of determining the randomness of the position chain by the randomness of the working pool:

[0129] 2.7.1 Establish an empty transitional position chain tmp_chain with a length of (1 / 2)length(vector i ).

[0130] 2.7.2 Sequentially extract the values represented by every two bits of the dynamic drive vector vector i as jump values to obtain a jump value sequence rp j (j = 0, 1, …, (1 / 2)length(vector i ) - 1).

[0131] 2.7.3 Let p0 = rp0, p j = pj-1 +rp j +1, tmp_chain(j) = pos_chain(ls i -L min ,p j ), and starting from j, exclude the position element pos_chain(ls i -L min ) from the position chain (pos_chain(ls i -L min ,p j ), where j = 0, 1,..., min((1 / 2)length(vector i ) - 1, ls i -1).

[0132] Then import part or all of pos_chain(ls i -L min ) into tmp_chain.

[0133] 2.7.4 When (1 / 2)length(vector i ) < ls i , append (1 / 2)length(vector i ) position elements from the transitional position chain tmp_chain to the position chain pos_chain(ls i -L min ) after the ls i -(1 / 2)length(vector i ); when (1 / 2)length(vector i ) ≥ ls i , directly replace the position chain pos_chain(ls i -L min ) with the transitional position chain tmp_chain.

[0134] 2.8 Dynamic driving vector vector i Metabolism

[0135] The metabolism of the dynamic driving vector vector i is one of the keys to ensuring the randomness of the complex reconstructed and regenerated key segments. There are various metabolism methods for the dynamic driving vector vector i . This specification exemplifies two methods for determining the randomness of the dynamic driving vector vector i from the randomness of the working pool:

[0136] 2.8.1 For the originally extracted dynamic driving vector vector i-1The byte segments of obtain the dynamic drive vector vector by shifting one byte backward in the working pool round by round (continuing from the head after reaching the end of the working pool). i .

[0137] 2.8.2 Extract or encrypt / decrypt the initially secretly agreed dynamic drive vector vector0 between both parties from the working pool, and use the dynamic drive vector vector of the previous round as the basis round by round i-1 XOR with an equal-length bits string that is pseudo-randomly determined in the working pool and has a different position from the dynamic drive vector vector of the previous round i-1 to generate a new dynamic drive vector vector i .

[0138] The association between bit extraction logic and bit metabolism logic

[0139] 2.9 The supporting use of bit extraction logic and bit metabolism logic

[0140] This specification shows four bit extraction logics and two bit metabolism logics, and does not exclude other bit extraction logics and bit metabolism logics.

[0141] The supporting use of bit extraction logic and bit metabolism logic is one of the keys to realizing an infinitely non-repeating regenerated key bit segment sequence of 'pseudo-randomly misaligned extraction of unmetabolized construction source bit positions or re-extraction of metabolized construction source bit positions'. Different matches of the two can construct different regenerated key bit segment sequences and achieve different coverage rates of the regenerated key bit segment sequences for the set of natural numbers. Its effect is particularly obvious in the misaligned superposition encryption of multiple regenerated key bit segment sequences.

[0142] For the bit extraction logic and bit metabolism logic presented in this specification, there are a total of eight available supporting methods. To avoid repetition, Figure 2 , 3 , and 4 each show one of them, basically summarizing the characteristics of various supporting methods. Among them, Figure 2 shows the matching working form of progressive carry extraction logic and sequential bit extraction metabolism logic. Figure 3 shows the matching working form of progressive chain extraction logic and extracted bit metabolism logic. Figure 4 shows the matching working form of bit jump extraction logic and extracted bit metabolism logic.

[0143] 2.9.1 Bit extraction logic directly acts on the current round of encryption, and bit metabolism logic affects subsequent rounds of encryption.

[0144] 2.9.2 The higher the randomness of the bit metabolism logic in the working pool metabolism, the higher the coverage rate of the regenerated key bit segment sequence to the natural number set. The higher the coverage rate of the regenerated key bit segment sequence to the natural number set, the closer the present invention is to a perfect securitization system.

[0145] 2.9.3 For the logic of postponing the position extraction, when the selected metabolic target area overlaps with the structural source, the extracted position metabolic logic is the same as the postponing position metabolic logic.

[0146] 2.9.4 For the deferred bit metabolism logic, in addition to matching the deferred bit acquisition logic, when the starting position of the metabolism target area is selected as the starting position of the manipulation source, the randomness of the regenerated key bit segment in the subsequent round is higher.

[0147] 2.9.5 The use of the extracted bit metabolism logic ensures that there are no duplicate bits that have not been metabolized in the working pool. When the deferred bit extraction logic is used to match the deferred bit metabolism logic, there are no duplicate bits that have not been metabolized in the working pool.

[0148] 2.9.6 When the deferred bit metabolism logic matches the non-deferred bit extraction logic, although there will be repeated unmetabolized bits in the working pool of the round, since there are no unmetabolized bits in the construction source during the rotation cycle of the working pool, the deferred bit metabolism logic has a higher overall metabolism rate for the working pool in the round-by-round encryption process, which makes the working pool have a higher coverage rate of the natural number set.

[0149] 2.9.7 Figure 6 The comparison shows the difference between the non-recursive chain position extraction logic / extracted position metabolism logic matching and the recursive chain position extraction logic / extracted position metabolism logic matching. In the former, the extraction position and the metabolism position correspond in order. In the latter, since the extraction positions are arranged in the order specified by the position chain, the extraction positions and the metabolism positions are pseudo-randomly misplaced.

[0150] 2.9.8 In the single-reconstruction encryption model, the logic of postponing the position of the position is likely to form a security vulnerability, so it is not suitable for use in the single-reconstruction encryption model. However, due to its higher utilization rate of the working pool, the effect of mixing the logic of postponing the position of the position and the logic of non-postponing the position of the position in the staggered superposition encryption of multiple regenerated key bit segments is better.

[0151] 2.9.9 To ensure the 're-extraction of metabolized source bits', the bit metabolism logic that matches the deferred bit-lifting logic must be the deferred bit-lifting metabolism logic.

[0152] 2.9.10 Rearrange the pseudo-random bits of the output pseudo-random string before generating the regeneration key bit segment Is optional (here optional means not to choose pseudo-random bit rearrangement without damaging the feasibility of the operation structure of the present invention), the pseudo-random bit conversion of the original metabolic source pseudo-random string before the metabolism in the working pool The pseudo-random bit rearrangement in is necessary. At the same time, using pseudo-random bit rearrangement and pseudo-random bit conversion

[0153] 2.9.11 Pseudo-random bit conversion has three purposes: to ensure 'extracting the bit positions of the constructed source that have been metabolized by repositioning', to eliminate the diffusion of the non-uniform distribution of '0' and '1' in the working pool, and to avoid the absolute homogenization of the distribution of '0' and '1' in the working pool. The technical means adopted include: pseudo-random bit rearrangement, bit-by-bit swapping while performing pseudo-random bit rearrangement, and intermittently adding sugar.

[0154] The purpose of pseudo-random bit rearrangement is to update the '0' / '1' arrangement based on the original '0' / '1' ratio in the working pool.

[0155] Bit-by-bit swapping while performing pseudo-random bit rearrangement aims to eliminate the probability of the imbalance in the ratio of '0' and '1' bit values in the working pool and block the diffusion of this imbalance during the construction of the regenerated key bit segment sequence.

[0156] Adding sugar means: using the pseudo-random change characteristics of the calculation parameters in the chaotic calculation structure, according to the intermittently occurring states of the calculation parameters (for example: (a), the position element at a specific position in the position chain is equal to 0 or ls i ; or (b), a certain determined byte value of the dynamic drive vector vector i is equal to 0 or ls i ; (c), the combination of (a) or (b) holds without contradiction. The combination of (a) or (b) holding without contradiction means: (1) the position element at a specific position in the position chain is equal to 0, and / or a certain determined byte value of the dynamic drive vector vector i is equal to 0; (2) the position element at a specific position in the position chain is equal to ls i , and / or a certain determined byte value of the dynamic drive vector vector i is equal to ls i ; (3) the position element at a specific position in the position chain being equal to 0 and a certain determined byte value of the dynamic drive vector vector i being equal to ls i do not hold simultaneously, and the position element at a specific position in the position chain is equal to lsi is not simultaneously established with the value of a certain determined byte of the dynamic drive vector vector i (This does not exclude the intermittent occurrence states of other calculation parameters.) Trigger to replace the metabolic source pseudo-random string with an all-'0' or all-'1' bit string. Due to the bit-by-bit interchange has a probability of causing an absolute uniform distribution of '0' and '1' in the working pool, which will weaken the randomness of the regenerated key bit segment sequence. Adding sugar will destroy this absolute uniform distribution. Due to the randomness of the metabolic target distribution and the intermittency of the trigger conditions, the sugar addition process can still ensure the randomness of the '0' and '1' distribution in the working pool.

[0157] 2.9.12 Pseudo-random bit conversion The pseudo-random bit rearrangement in must be different from the pseudo-random bit rearrangement, which ensures the mutual independence between the pseudo-random change trajectory of the regenerated key bit segment sequence and the pseudo-random change trajectory of the working pool replacement.

[0158] 2.9.13 In each round, the original metabolic source pseudo-random string must be used and can only be used once for interchange.

[0159] 2.9.14 Sugar addition needs to be implemented at intervals of several rounds, and the number of intervals needs to be pseudo-randomly determined. And with equal probability, alternately use an all-'0' or all-'1' bit string as the metabolic source pseudo-random string.

[0160] Implementing 'pseudo-random misalignment extraction of unmetabolized construction source bit positions or re-position extraction of metabolized construction source bit positions' does not prove that the regenerated key bit segment sequence is infinitely non-cyclic. The present invention adopts two measures to achieve infinitely non-cyclic encryption of the regenerated key bit segment sequence: chaotic calculation structure and misaligned segment superposition logic structure. The chaotic calculation structure eliminates the probability of periodic occurrence of repeated sub-bits strings in the regenerated key bit segment sequence during reconstruction, but this elimination cannot be proven to be complete. The misaligned segment superposition logic structure of the regenerated key bit segment sequence performs the entanglement between different regenerated key bit segment sequences and the chaotic entanglement of the pseudo-random string space with respect to the regenerated key bit segment sequence space during the encryption process. Completely block the periodicity of the change of the regenerated key bit segment sequence.

[0161] 3 Expansion of the effect of 'pseudo-random misalignment extraction of unmetabolized construction source bit positions or re-position extraction of metabolized construction source bit positions' by the chaotic calculation structure

[0162] Under a fixed computing structure, the output generated from a finite bit set cannot guarantee the absence of periodic repetitions. Similarly, under a fixed computing structure, 'pseudo-randomly extracting unmetabolized construction source bit positions from the pseudo-random dislocation or re-extracting the construction source bit positions that have been metabolized' also cannot guarantee the non-periodic occurrence of repeated sub-sequences of the regeneration key bits. The bit metabolism logic in the chaotic computing structure has a chaotic effect on the metabolism of the working pool, making the process of obtaining the regeneration key bit segment sequence from a finite set have chaotic characteristics, and its effects are reflected in:

[0163] (1) The pseudo-random change in the bit segment length caused by the chaotic computing structure breaks the regularity of the change of the metabolized bits in the working pool.

[0164] (2) When the starting byte of the construction source cyclically advances round by round in the working pool, the pseudo-random change in the bit segment length caused by the chaotic computing structure breaks the regularity of the periodic change of the repeatedly extracted bits.

[0165] The destruction of the above regularity stems from the pseudo-randomness of processing in units of bit positions, and has good randomness and uniform distribution.

[0166] 4-bit segment superposition logic structure

[0167] The bit segment superposition logic structure refers to: a dislocation superposition encryption structure of more than one different regeneration key bit segment sequences on the plaintext bit segment when encrypting the plaintext based on the chaotic computing structure. The bit segment superposition encryption is essentially different from the repeated encryption of multiple regeneration key bit segment sequences. It is a specific logical winding encryption implemented by two or more regeneration key bit segment sequences using the chaotic computing structure. Since a single regeneration key bit segment sequence itself has a chaotic computing structure, the chaotic winding effect of the regeneration key bit segment sequence generated by their bit segment superposition can reach the power-level expansion of the chaotic effect of a single regeneration key bit segment sequence.

[0168] The regeneration key bit segment sequences participating in the bit segment superposition are all based on the same chaotic computing structure, and the mutual winding of different regeneration key bit segment sequences in the encryption process is realized by using the dislocation between different regeneration key bit segment sequences and the same-scale segmentation of the regeneration key bit segments, plaintext bit segments, and ciphertext bit segments. Such a logical structure can further embed the pseudo-random bit winding of the transitional pseudo-random string (see 4.5) in the encryption process. Its essence is the expansion of the regeneration key bit segment sequence space by the transitional pseudo-random string space in a chaotic winding manner.

[0169] Figure 7 What is shown is a simple bit segment superposition logic structure. Figure 8 What is shown is a bit segment superposition logic structure embedded with pseudo-random bit winding.

[0170] Combined with the appendix Figure 7 Introduce the simple bit segment superposition logic structure:

[0171] Figure 7 Shown is the simple overlapping logic structure of two regenerated key bit segments. The more complex simple overlapping logic structures follow the same principle. 4.1 Overlapping after segment splitting based on the chaotic computing structure

[0172] As Figure 7 shown, in the encryption / decryption process, two regenerated key bit segment sequences (k1f i ||k1l i , i = 0, 1,...; k2f i ||k2l i , i = 0, 1,...; where '||' is the concatenation symbol, the same below) are alternately intertwined with segment splitting. Among them, the regenerated key bit segments bsk1 i 、 bsk2 i are respectively split into two half-bit segments, k1f i and k1l i , k2f i and k2l i . In the calculation, the first half-bit segment of one regenerated key bit segment sequence and the second half-bit segment of the other regenerated key bit segment sequence are alternately superimposed for encryption in order (k1f i / k2l i-1 , k1l i / k2f i ).

[0173] 4.2 Synchronization of segment splitting

[0174] 4.2.1 Determining ls i .

[0175] 4.2.2 Determining the splitting scale

[0176] Using λ ((1 / 2)L min , L max ) related to the bit segment length limit values L min ≤λ<(1 / 2)L max ) as the bit difference (or sd, see i ) between the first regenerated key bit segment sequence bsk1 i (i = 0, 1, 2,...) and the second regenerated key bit segment sequence bsk2 Figure 7 (i = 0, 1, 2,...). Thus, there is a relationship between the bit segments of the two regenerated key bit segment sequences: p2s i = p1s i + sd (p1s i , p2s i are the bit segments of bsk1 i and bsk2 i respectively)The starting position). Using this sd as the first regeneration key bit segment sequence bsk1 i The length l1f of the first half bit segment of (i = 0, 1, 2,...) i , using ls in 4.2.1 i Calculate the first regeneration key bit segment sequence bsk1 i The length l1l of the second half bit segment of (i = 0, 1, 2,...) i And use it as the second regeneration key bit segment sequence bsk2 i The length l2f of the first half bit segment of (i = 0, 1, 2,...) i : l1l i = l2f i = ls i - l1f i , the second regeneration key bit segment sequence bsk2 i The length l2l of the second half bit segment of (i = 0, 1, 2,...) i Is equal to the length l1f of the first half bit segment of the first regeneration key bit segment sequence bsk1 i Of (i = 0, 1, 2,...) i .

[0177] From the value formula of λ (1 / 2)L min ≤ λ < (1 / 2)L max It can be seen that this way of segment misalignment superposition is still restricted by the chaotic calculation structure.

[0178] 4.3 Entanglement between different regeneration key bit segment sequences

[0179] The simplest entanglement method is to directly use the misaligned corresponding half bit segments of two regeneration key bit segment sequences to perform misaligned alternating XOR on the two half bit segments of the plaintext, which makes the plaintext always encrypted by misaligned superposition of different regeneration key bit segment sequences. More complex entanglement can be seen in the following misaligned superposition logic structure with embedded pseudo-random bit entanglement.

[0180] 4.4 Working pool metabolism in the misaligned superposition logic structure

[0181] 4.4.1 Select the bit metabolism logic according to the bit extraction logic adopted by the regeneration key bit segment sequence: use the postponed bit extraction metabolism logic for the postponed bit extraction logic, and use the extracted bit metabolism logic for other bit extraction logics.

[0182] 4.4.2 The bit metabolism logic adopts a composite form of alternating use of the extracted bit metabolism logic and the postponed bit extraction metabolism logic (the bit extraction logic also adopts a composite form of alternating use of non-postponed bit extraction logic and postponed bit extraction logic).

[0183] 4.4.3 When adopting the multiple error segment superposition logic structure, different bit extraction logics, bit metabolism logics, different manipulation sources, and construction sources can be used to obtain different metabolism sources and different metabolism target areas. The metabolism severity of the position chain can be appropriately reduced according to the encryption efficiency requirements.

[0184] Combined with Figure 8 Introduce the multiple error segment superposition logic structure of multiple embeddings of pseudo-random bit winding:

[0185] Figure 8 What is shown is the error segment superposition logic structure of three embeddings of pseudo-random bit winding for two groups, each containing two sequences of regenerated key bit segments. The more multiple error segment superposition logic structures of more embeddings of pseudo-random bit winding are the same. The error segment superposition logic structure with the pseudo-random bit winding shifted backward by half a key bit segment (that is, the pseudo-random bit winding is embedded in the secondary regenerated key bit segment sequence, see Figure 9 ) is the same.

[0186] Figure 8 The construction of the regenerated key bit segment, the metabolism of the working pool, and the stack scheduling in the error segment superposition process are omitted, focusing on the bit segment splitting, synchronization processing, and the integration of the embedded pseudo-random bit winding. For the complete calculation process of the multiple error segment superposition with multiple embeddings of pseudo-random bit winding, please refer to Figure 8 ’(For clearly showing the operation order, Figure 8 ’s intermediate calculation steps only replace the old calculation element with the new calculation element, the new calculation element, the calculation, and its result).

[0187] Next, refer to Figure 8 Introduce the multiple error segment superposition logic structure of multiple embeddings of pseudo-random bit winding for two groups, each containing multiple sequences of regenerated key bit segments.

[0188] 4.5 Using the existing position chain to realize the pseudo-random bit winding of the transitional pseudo-random string

[0189] The transitional pseudo-random string refers to the pseudo-random string generated by the previous regenerated key bit segment sequence between different rounds of each layer of encryption or used for the calculation of the subsequent pseudo-random bit winding or regenerated key bit segment sequence.

[0190] The pseudo-random bit winding refers to randomly rearranging the order of each bit in a transitional pseudo-random string. This processing causes further bit winding between the transitional pseudo-random strings of different rounds under the error segment superposition logic structure. Different from the pseudo-random bit rearrangement of the bit extraction logic and the pseudo-random bit conversion of the bit metabolism logic What is different from the pseudo-random bit rearrangement in [is that]: (1) the object of the pseudo-random bit winding is the transitional pseudo-random string; (2) the winding needs to be easily reversible. The purpose of (1) is to achieve re-winding in the vertical direction of the winding between different regenerative key bit segment sequences; the purpose of (2) is to ensure that it can be decrypted and the decryption calculation amount is not increased. This specification uses a position chain pos_chain(ls i -L min ) with the same length as the bit segment to specify bit pairs in the transitional pseudo-random string and swap the bit values of the bit pairs.

[0191] 4.5.1 Perform co-scale segmentation on the plaintext bit segment, the regenerative key bit segment, and the ciphertext bit segment based on the chaotic computing structure; use sd in 4.2.2 to determine the bit segment segmentation scale: sd, ls i -sd.

[0192] 4.5.2 Construct two groups of primary regenerative key bit segment sequences and secondary regenerative key bit segment sequences belonging to different segmentations: each regenerative key bit segment sequence within and between groups is different from each other

[0193] 4.5.2.1 Establish two groups of regenerative key bit segment sequences; bsk1 i,q , bsk2 i,q , q = 0, 1,..., s i = 0, 1,... (where q is the subscript of each regenerative key bit segment sequence belonging to different groups (1 or 2), s is the number of regenerative key bit segment sequences in each group, and i is the round number).

[0194] 4.5.2.2 Each regenerative key bit segment in each regenerative key bit segment sequence follows the scale segmentation in 4.5.1: k1f i,q (with a length of sd), k1l i,q (with a length of ls i -sd), k2f i,q (with a length of ls i -sd), k2l i,q (with a length of sd); the plaintext bit segment is also segmented at the same scale Mf i (with a length of sd), Ml i (with a length of ls i -sd).

[0195] 4.5.2.3 Determine different bit taking logics, bit metabolism logics, or different construction sources and manipulation sources for each regenerative key bit segment sequence to ensure that each regenerative key bit segment is different.

[0196] 4.5.3 Cross-segment superposition encryption of different regenerative key bit segment sequences with embedded pseudo-random bit winding based on co-scale segmentation

[0197] 4.5.3.1 Store each latter half key segment k2l in the secondary regeneration key segment sequence group using s buffer areas with a length of sd i,q , where q = 0, 1, 2,..., s, for lagged segment encryption.

[0198] 4.5.3.2 Except for the first round (where there is no k2l 0,-1 in the first round, so only the half - segment encryption of k2f 0,0 is implemented during the segment encryption of the secondary regeneration key segment sequence group), the other rounds perform segment encryption in the following order (for the used identifiers, refer to the notes after 4.5.4.5):

[0199] k1f i,q ||k1l i,q , q = 0;

[0200] i, r, r = r + 1;

[0201] k2l i-1,q ||k2f i，q ; q = q + 1;

[0202] i, r; r = r + 1;

[0203] ……

[0204] k1f i,s ||k1l i,s ;

[0205] i, 2s - 1;

[0206] k2l i-1,s ||k2f i,s ;

[0207] 4.5.4 Segment decryption of different regeneration key segment sequences with embedded pseudo - random bit winding based on same - scale segmentation

[0208] During decryption, reconstruct or extract the required computational amount according to the encryption order and complete the corresponding metabolism, and then perform decryption calculations in reverse order using the obtained computational amount. 4.5.4.1 When initializing the chaotic computing structure, establish (1) a position chain stack stack_chain with a length of L max for storing position chains; (2) a position chain stack stack_chain with a length of L maxThe half-segment stack stack_k2f of length sd is used to store the first half-segment of s sub-regenerated key segments; (3) The half-segment stack stack_k2l of length sd is used to store the second half-segment of s sub-regenerated key segments for the next round of misaligned segment splicing; (4) The misaligned half-segment stack s_stack_k2l of length sd is used to copy out the half-key segment k2l stored in the half-segment stack stack_k2l in the previous round i-1,q , so as to splice the misaligned sub-regenerated key segment k2l i-1,q ||k2f i,q ; (5) The whole-segment stack stack_bsk1 of length L max is used to store the first regenerated key segment used in the current round. 4.5.4.2 Except for the first round, at the beginning of each round of decryption, copy the second half-segments of all the sub-regenerated key segments pushed into stack_k2l in the previous round into s_stack_k2l, and clear stack_k2l

[0209] 4.5.4.3 Except for the first round, each round performs s times of computational reconstruction or extraction in the order of encryption processing: (1) Reconstruct the regenerated key segment bsk1 i,q and push it into the whole-segment stack stack_bsk1, and perform the metabolism of the position chain pos_chain(ls i -L min ); (2) Push the position chain pos_chain(ls i -L min ) into the position chain stack stack_chain and perform the metabolism of the position chain pos_chain(ls i -L min ); (3) Reconstruct the regenerated key segment bsk2 i,q , q = 0, 1,..., s - 1 and push it into the half-segment stacks stack_k2f, stack_k2l and perform the metabolism of the position chain pos_chain(ls i -L min ); (4) Except for the s-th time, push the position chain pos_chain(ls i -L min ) into the position chain stack stack_chain and perform the metabolism of the position chain pos_chain(ls i -L min ).

[0210] 4.5.4.4 Except for the first round, other rounds decrypt with misaligned segments in the reverse order of encryption (see the notes after 4.5.4.5 for the used identifiers):

[0211] k2l i-1,q ||k2f i,q , q = s;

[0212] i,r,r=2s-2;r=r-1;

[0213] k1f i,q ||k1l i,q , q=s;q=q-1;

[0214] …

[0215] i,r,r=r-1;

[0216] k2l i-1,0 ||k2f i,0 ;

[0217] i,0;

[0218] k1f i,0 ||k1l i,0 ;

[0219] 4.5.4.5 The length of the half-bit segment in each round of decryption is sd or ls i -sd, omit L max -ls i excess part.

[0220] Note: In the above formulas (4.5.3.2) and (4.5.4.4): It indicates that the transitional pseudo-random string generated by the previous step calculation is XORed with the regenerated key bit segment of the wrong segment or the wrong segment specified later; Indicates that the bit wrapping is performed with the position chain pos_chain(r) specified later (1) for encryption, r = 0, 1, ..., 2s-2, or (2) the position chain pos_chain(r) released from the position chain stack stack_chain used for decryption, r = 2s-2, 2s-3, ..., 1, 0 (where r specifies the lsth position in the position chain set) i -L min Position chain pos_chain(ls i -L min ) for pseudo-random bit winding in the position chain of the rth metabolism in the 2s-1 metabolism); Indicates the position chain pos_chain(ls i -L min ) Metabolism (decryption, since each position chain pos_chain (ls i-L min ) metabolism, there is no need to implement the position chain pos_chain(ls i -L min )';' indicates the end of a calculation step.

[0221] 4.6 Staggered winding with embedded pseudo-random bit winding

[0222] Depend on Figure 8 The pseudo-random bit winding shown is implemented for the full bit segment of the first regenerated key bit segment. Due to the staggered effect, this pseudo-random bit winding acts on the transitional pseudo-random string encrypted by the first regenerated key bit segment and the transitional pseudo-random string encrypted by the regenerated key bit segment of the previous round of the second half bit segment and the current round of the first half bit segment staggered and recombined, which realizes another staggered winding between the previous and next bit segments based on the staggered winding between the two sets of different regenerated key bit segment sequences.

[0223] 4.7 Working pool metabolism in the staggered superposition logic structure embedded in pseudo-random bit entanglement

[0224] 4.7.1 Select the bit metabolism logic according to the bit retrieval logic used in the regenerated key bit segment sequence: the bit jump retrieval logic uses the extracted bit metabolism logic, the deferred bit retrieval logic uses the deferred bit metabolism logic, and other bit retrieval logics use the extracted bit metabolism logic.

[0225] 4.7.2 In the staggered superposition model, the bit metabolism logic is preferably a hybrid form in which the extracted bit metabolism logic and the deferred bit metabolism logic are used alternately (the bit retrieval logic also adopts a composite form in which the non-deferred bit retrieval logic and the deferred bit retrieval logic are used alternately).

[0226] 5. Some issues related to complex and reconstructed logical structures

[0227] 5.1 Association of Chaos Computing Structure Customized Configuration Logic

[0228] The customized chaos computing structure is run only once and its overhead is negligible.

[0229] Different customized configurations of the composite logic structure result in different chaotic computing structures. The present invention achieves customization through structural configuration quantities and related configuration logic. This section focuses on clarifying the connection between these configuration logic units:

[0230] 5.1.1 The key length is determined by the structural configuration quantity, and then the density of the security system and the magnitude of resource consumption are determined. Here are some structural configuration quantities with scale significance to clarify the magnitude of density and resource consumption: 512, 640, 768, 896...

[0231] 5.1.2 Determine the key size, select the pool size, the initial working pool size according to the configuration logic based on the structure configuration quantity, and load the initial working pool with the key according to the initial working pool size.

[0232] 5.1.3 Determine the acquisition position of the dynamic drive vector vector0 pseudo-randomly according to the key from the working pool, and extract the initial dynamic drive vector vector0.

[0233] 5.1.4 Calculate the maximum value L of the bit segment length limit with the initial dynamic drive vector vector0 max , the minimum value L of the bit segment length limit min .

[0234] 5.1.5 Generate the pseudo-ciphertext pM according to the difference between the selected pool size and the initial working pool size.

[0235] 5.1.6 Generate the end-of-plaintext symbol EOP according to the initial dynamic drive vector vector0.

[0236] 5.1.7 Generate the position chain set pos_chain according to the maximum value L of the bit segment length limit max and the minimum value L of the bit segment length limit min and initialize it.

[0237] 5.2 There are multiple methods for initializing the position chain set pos_chain. This specification uses a method that leads the randomness of the position chain by the randomness of the key:

[0238] 5.2.1 Set the initial value of the position chain set pos_chain(j), j = 0, 1, 2,..., L max -L min to {0, 1, 2,..., L min +j-1}, j = 0, 1, 2,…, L max -L min .

[0239] 5.2.2 Set the position chain initialization control quantity pos_init0 to the value of the first byte of the initial dynamic drive vector vector0.

[0240] 5.2.3 Initialize the position chain pos_chain(j) one by one for j (j = 0, 1, 2,…, L max -L min ) in a loop

[0241] 5.2.3.1 Initialize the position chain pos_chain(j) by the method described in 2.7 in the integration of bit-taking logic and bit metabolism logic with (pos_init j%initLmt) + tertiary metabolism (initLmt is the number represented by the first three bits of vector0).

[0242] 5.2.3.2 Reset the control variable pos_init of the position chain initialization for each j + 1 j+1

[0243]

[0244] Where: is the exclusive OR operation.

[0245] 5.2.3.3 j = j + 1.

[0246] 5.3 Due to the high uniformity of the pseudo-random bit sampling logic, there will be a high probability (about equal to 1 / 256) of the byte '0' or 'F' appearing in the regenerated key bit segment. This results in a high probability of directly outputting the plaintext byte or its inverse byte (the exclusive OR of the plaintext byte and 'F') in the ciphertext encrypted only with a single complex reconstruction logic structure. The above problem does not exist for the misaligned segment superposition logic structure with embedded pseudo-random bit winding. Embodiment

[0247] This specification selects the non-superimposed & single metabolism model with progressive carry logic / sequential carry extraction metabolism logic as Embodiment 1, and selects the misaligned segment superposition model with double superposition & double metabolism with embedded pseudo-random bit winding of progressive chain sampling logic / sequential carry extraction metabolism logic and bit jump sampling logic / extracted bit metabolism logic as Embodiment 2. The purposes are: (1) To illustrate the basic form of the composite logic structure and the associated form of the chaotic computing structure with bit sampling logic and bit metabolism logic through Embodiment 1; (2) To illustrate the more complex associated form of the composite logic structure through Embodiment 2: the synergistic effect of the chaotic computing structure on the misaligned segment superposition logic structure and the chaotic form with embedded pseudo-random bit winding. Since the computing structures with more complex misaligned segment superposition are the same in principle, Embodiment 2 only selects the double superposition model with a single embedded pseudo-random bit winding.

[0248] Non-superimposed & single metabolism model configured with progressive carry logic / sequential carry extraction metabolism logic in Embodiment 1

[0249] Computing parameters and calculation formulas of Embodiment 1 (the operation formulas are all based on the real number form)

[0250] Chaotic computing structure configuration

[0251] 1 As a secret agreement between the encryption / decryption parties, define the structure configuration quantity ctl of Embodiment 1 init = 640, and let the key length be equal to it.

[0252] 2 Define the selection pool and working pool of Embodiment 1, and define and generate the pseudo-plaintext

[0253] 2.1 Define the selection pool SPool

[0254] The selection pool SPool satisfies: length(SPool) = 2 * ctl init (1)

[0255] 2.2 Define the working pool SPool work And load the working pool SPool work

[0256] Define the initial working pool SPool work Satisfy: length(SPool work ) = ctl init

[0257] Set the initial content of the working pool SPool work to be the key.

[0258] 3 As a secret agreement between the encryption / decryption parties, define the dynamic drive vector vector of Embodiment 1 i as a substring in the selection pool Spool:

[0259]

[0260] Where: vectstart0 is the byte position determined by the first three bytes of the key

[0261] vectstart0 = ((Spool work [0] + Spool work [1] + Spool work [2]) % 640) / 8,

[0262] l is a positive integer, satisfying 64 = l,

[0263] length(Spool work ) is the length of the working pool, and its initial value is the length of the key,

[0264] is a bits string of length l pseudo-randomly specified by vectstart0 in the key (continuing from the head after h reaches the end of the working pool).

[0265]

[0266] vectstart i is the first byte first bit of the i-th round dynamic drive vector in the working pool (continuing from the head after reaching the end of the working pool),

[0267] vector i is the dynamic drive vector for the i-th round,

[0268] as shown in (2’), the dynamic drive vector is shifted one byte round by round (continues from the head after reaching the end of the working pool),

[0269] since l = 64, vector i has a length of 8 bytes.

[0270] 4 Calculate the maximum value L of the bit segment length limit in Embodiment 1 max and the minimum value L of the bit segment length limit min

[0271] 4.1 Calculate the maximum value L of the bit segment length limit max

[0272] L max = ctl init / 12 + ((vector0[0] + vector0[1]) % (ctl init / 128)) + ctl init / 128 (3)

[0273] where: vector0[0] and vector0[1] are the first two bytes of the initial dynamic drive vector vector0.

[0274] 4.2 Calculate the minimum value L of the bit segment length limit min

[0275] L min = ctl init / 12 - ((vector0[2] + vector0[3]) % (ctl init / 128)) - ctl init / 128 (4)

[0276] where: vector0[2] and vector0[3] are the third and fourth bytes of the initial dynamic drive vector vector0.

[0277] 5 Define the pseudo-plaintext pM and the plaintext end symbol EOP in Embodiment 1

[0278] 5.1 Generate the pseudo-plaintext pM according to 2 as a pseudo-random string with a length satisfying length(pM) = ctl init

[0279] 5.2 Define the plaintext end symbol EOP as a substring from the initial working pool with a length satisfying length(EOP) = length(vector0) ​Bit string generated by XOR with the initial dynamic drive vector vector0:

[0280]

[0281] where: l = length(vector0),

[0282] vectstart0 see 3.

[0283] 6 Define the position chain set and initialize it

[0284] 6.1 Define the position chain set pos_chain(j,k), j = 0,1,2,…,L max -L min , k = 0,1,...,L min +j-1(6)

[0285] 6.2 The initialization of the position chain set pos_chain follows the description 5.2 of the sequence encryption method of the complex reconstruction key.

[0286] Encryption / decryption calculation formula and calculation unit of Embodiment 1

[0287] 7 Define the encrypted plaintext M (rebuild plaintext) as the concatenation of the pseudo-plaintext pM, plaintext, plaintext end symbol EOP, and padding pseudo-random string ms additn of

[0288] M = pM||plaintext||EOP||ms additn (7)

[0289] where: the padding pseudo-random string ms additn has a length of L max .

[0290] 8 Pseudo-randomly construct the ls for each round of encryption in Embodiment 1 i

[0291] 8.1 Set the first-round bit segment length

[0292] ls0 = (vector0[2]) % (L max -L min ) + L min (8)

[0293] where: vector0[2] is the third byte of the initial dynamic drive vector vector0.

[0294] 8.2 Define the fixed-length function for each round of bit segments

[0295] ls i = (vectori [vector i [2] % 8]) % (L max -L min ) + L min (8’)

[0296] 9 Pseudo - random construction, regeneration key bit segment of Example 1 bsk i

[0297] 9.1 Define the construction source SPool work The construction byte pickbyte in i,j (The calculation formula is in bytes):

[0298] pickbyte i,0 = (pickbyte i-1,0 + 1) % workbyte (9)

[0299] pickbyte 0,0 = vector0 % workbyte (9’)

[0300] Where: vector0 is the initial drive vector,

[0301] Workbyte is the length of the work pool calculated in bytes (the same below),

[0302] pickbyte i-1,0 is the first construction byte of the previous round,

[0303] (9’) pickbyte in 0,0 is the first construction byte of the first round, pickbyte in (9) i,0 is the first construction byte of the i - th round after that, pickbyte i,0 progresses one byte by one byte in the work pool SPool work (continues from the beginning after reaching the end of the work pool).

[0304] pickbyte i,j = (pickbyte i,j-1 + 1) % workbyte (9”)

[0305] Where: pickbyte i,j is the j - th construction byte of the i - th round, and progresses byte by byte in the work pool SPool work (continues from the beginning after reaching the end of the work pool).

[0306] 9.2 Define the construction control value pickdriveval i,j

[0307] 9.2.1 Define the first manipulation element Pickdrivelmt in the manipulation source i,0 (The calculation formula is in bits)

[0308] pickdrivelmt 0,0 = ((pickbyte 0,0 + workbyte) * 8 - vector0[0]) % length(Spool work )(10)

[0309] pickdrivelmt i,0 = (pickdrivelmt i-1,0 + 1) % workbyte(10’)

[0310] Where: pickdrivelmt 0,0 is a position in the working pool, with a relative bit difference pseudo-randomly determined by the key from pickbyte 0,0

[0311] 9.2.2 Manipulation element sequence in the manipulation source

[0312] pickdrivelmt i,j = (pickdrivelmt i,j-1 + 4) % length(Spool work ), j = 0,..., ls i - 1(10”)

[0313] pickdrivelmt i,j progressively advances by 4 bits for each manipulation element in the working pool SPool work and continues from the beginning after reaching the end of the working pool, obtaining the manipulation element sequence pickdrivelmt i,j , j = 0, 1,..., ls i - 1.

[0314] 9.2.3 Extract the manipulation value pickdriveval from the manipulation element i,j

[0315] If the value of the last bit of the manipulation element pickdrivelmt i,j is '0', then extract the value of its first 3 bits as the manipulation value pickdriveval i,j , otherwise extract the value of its last 3 bits as the manipulation value pickdriveval i,j , obtaining the manipulation value sequence pickdriveval i,j , j = 0, 1,..., ls​i -1.

[0316] 9.3 Constructing the regeneration key segment bsk i

[0317] 9.3.1 Extract the first control value pickdriveval i,0 , locate the first construction byte Pickbyte of the construction source i,0 , clear the output pseudo-random string tmp_str(j), j = 0, 1, ..., ls i -1.

[0318] 9.3.2 Constructing a byte from the current pickbyte i,j Press current control value pickdriveval i,j Extract the value of the specified bit and update the element tmp_str(j) in the output pseudo-random string.

[0319] 9.3.3 Positioning to the next control value pickdriveval i,j+1 and the next construction byte pickbyte i,j+1 .

[0320] 9.3.4 Step j = j + 1, repeat 9.3.2 and 9.3.3 until the length of the output pseudo-random string reaches ls i .

[0321] 9.3.5 Output pseudo-random string tmp_str(j) without pseudo-random bit rearrangement, j = 0, 1, ..., ls i -1 as the regeneration key bit field bsk i .

[0322] 10. Delayed Metabolic Logic

[0323] 10.1 Define Metabolize Byte i,j ,j=0,1,2,...,ls i -1 (the calculation formula is in bytes):

[0324] metabolizebyte i,0 =pickdrivelmt i,0 (11)

[0325] metabolizebyte i,j =(metabolizebyte i,j-1 +1)%workbyte,j=0,1,…,ls i -1(11')

[0326] where: workbyte is the length of the working pool, in bytes.

[0327] metabolizebyte i,j In the working pool SPool work progress byte by byte (continuing from the beginning after reaching the end of the working pool).

[0328] 10.2 Obtain the metabolic source pseudo-random string metabol_str(j) (j = 0, 1, 2, …, ls i -1).

[0329] 10.2.1 Define the metabolic source pseudo-random string of the same length as the regeneration key bit segment bski metabol_str(j) (j = 0, 1, 2, …, ls i -1) of the same length as the regeneration key bit segment.

[0330] 10.2.2 If pos_chain(ls i -L min ) in the position chain pos_chain(ls i -L min ,0) = 0, then the metabolic source pseudo-random string metabol_str(j) = 0, (j = 0, 1, 2,..., ls i -1); if pos_chain(ls i -L min ) in the position chain pos_chain(ls i -L min ,0) = ls i then the metabolic source pseudo-random string metabol_str(j) = 1, (j = 0, 1, 2,..., ls i -1).

[0331] Otherwise

[0332] 10.2.3 For the original metabolic source pseudo-random string (i.e., the output pseudo-random string tmp_str(j) in 9.3.6, j = 0, 1,..., ls i -1), perform swaps one by one with the value of the bit specified by the position element in the position chain, and then splice the metabolic source pseudo-random string metabol_str(j) = tmp_str[pos_chain(ls i -L min ,j)], (j = 0, 1, 2,..., ls i -1).

[0333] 10.3 Use the metabolic source pseudo-random string metabol_str obtained in 10.2 to perform metabolic extraction and position shifting on the metabolic target area in the working pool

[0334] 10.3.1 Define the metabolic bit position metabolbit i (0) = 0 (12)

[0335] metabolbit i (j) = (metabolbit i (j - 1) + 1) % 8 (12’)

[0336] 10.3.2 Perform metabolism on the metabolic bit positions in each byte of the metabolic target area:

[0337] metabolizebyte i,j (metabolbit i (j)) = metabol_str(j), j = 0, 1, 2,..., ls i -1(13)

[0338] 11 Position chain pos_chain(ls i -L min ) metabolism

[0339] Perform metabolism on pos_chain(ls i -L min ) in the manner described in Instruction 2.7 of the sequence encryption method for complex reconstruction keys.

[0340] Encryption / decryption process control in Example 1

[0341] Encryption

[0342] 1 Let the structure configuration quantity ctl init = 640.

[0343] 2 Construct the selection pool Spool, working pool SPool work , the maximum value L of the bit segment length limit max , the minimum value L of the bit segment length limit min , calculate the length of the pseudo-plaintext pM and generate the pseudo-plaintext pM, the plaintext end symbol EOP, and construct the position chain set pos_chain one by one according to the above chaotic calculation structure configuration.

[0344] 3 Concatenate the plaintext M to be encrypted according to the encryption / decryption calculation formula and calculation unit 7 in Example 1, calculate the bit segment length ls0, and extract the initial dynamic drive vector vector0 according to the encryption / decryption calculation formula and calculation unit 8 in Example 1.

[0345] 4 According to the encryption / decryption calculation formula and calculation unit 9.2 of embodiment 1, the first control element pickdrivelmt is located in the control source i,0 And extract the first control value pickdriveval i,0 , locate the first construction byte Pickbyte of the construction source i,0 , and clear the output pseudo-random string tmp_str(j), j = 0, 1, ..., ls i -1.

[0346] 5 According to the encryption / decryption calculation formula of embodiment 1 and calculation unit 9.3, the pseudo-random string tmp_str(j) is extracted and output cyclically, j=0,1,…,1s i -1, construct the regeneration key segment bsk i .

[0347] 6 Sequentially extract the length ls from the plaintext M i The plaintext segment M i , and use the regeneration key bit segment bsk i For plaintext segment M i Perform XOR encryption.

[0348] 7 If the work pool has not reached maturity, the plaintext segment M i (i.e., pseudo plaintext pM i ) implements growth-stage metabolism on the working pool (see single complex reconstruction logic structure 1.5.5.1); otherwise, the working pool is metabolized using the deferred promotion metabolism logic according to the encryption / decryption calculation formula and calculation unit 10 of Example 1.

[0349] 8 According to the description of the sequence encryption method of the complex reconstruction key 2.7 position chain pos_chain (ls i -L min ) Metabolism, vector i Shift back one byte in the worker pool.

[0350] 9 Step i=i+1, calculate ls i , if the plaintext segment M i The length is less than ls i Then perform the following post-encryption processing, otherwise loop and execute the above 4 to 8.

[0351] 10. Concatenate the remaining bits after the calculation end bit of the plaintext into the ciphertext.

[0352] Decryption

[0353] 1Same as encryption 1.

[0354] 2. According to the above chaotic computing structure configuration, construct the selection pool Spool and the working pool SPool one by one work , the bit segment length limits the maximum value Lmax , the bit segment length is limited to the minimum value L min , calculate the length of the pseudo-plaintext pM, the plaintext end character EOP, and construct the position chain set pos_chain.

[0355] 3 Calculate the bit segment length ls0, and extract the initial dynamic driving vector vector0 according to the encryption / decryption calculation formula and calculation unit 8 of embodiment 1.

[0356] 4 According to the encryption / decryption calculation formula and calculation unit 9.2 of embodiment 1, the first control element pickdrivelmt is located in the control source i,0 And extract the first control value pickdriveval i,0 , locate the first construction byte Pickbyte of the construction source i,0 , and clear the output pseudo-random string tmp_str(j), j = 0, 1, ..., ls i -1.

[0357] 5 According to the encryption / decryption calculation formula of Example 1 and the calculation unit 9.3, the pseudo-random string tmp_str(j) is extracted and output cyclically, j=0,1,...,ls i -1, construct the regeneration key segment bsk i .

[0358] 6 Sequentially extract the length ls from the ciphertext C i C i , and use the regeneration key bit segment bsk i XOR decrypt the ciphertext segment C.

[0359] 7 If the working pool has not reached maturity, the decrypted plaintext segment M i (i.e., pseudo plaintext pM i ) implements growth-stage metabolism on the working pool (see single complex reconstruction logic structure 1.5.5.1), otherwise the working pool is metabolized using the deferred promotion metabolism logic according to the encryption / decryption calculation formula and calculation unit 10 of Example 1.

[0360] 8 According to the description of the sequence encryption method of the complex reconstruction key 2.7 position chain pos_chain (ls i -L min ) Metabolism, vector i Shift back one byte in the worker pool.

[0361] 9 Step i=i+1, calculate ls i , if the ciphertext segment C i The length is less than ls i Then execute the following post-decryption processing, otherwise loop and execute the above 4 to 8.

[0362] 9.1 Eliminate the pseudo plaintext pM from the decrypted plaintext.

[0363] 9.2 The reverse order L at the end of the decrypted plaintext max +length(vector0) position comparison plaintext end character EOP, if found, remove the plaintext end character EOP and the subsequent pseudo-random string ms additn ; If the plaintext end character EOP cannot be found, it means that an error occurred during the encryption, transmission, and decryption process.

[0364] Example 2 Double superposition & double metabolic staggered superposition model of embedded pseudo-random bit entanglement matching with progressive chain bit extraction logic / postponed bit metabolic logic and bit jump bit extraction logic / extracted bit metabolic logic

[0365] Since only one regeneration key bit segment sequence is used in each regeneration key bit segment sequence group of this embodiment (s=1, see the staggered segment overlay logic structure 4.5), this embodiment uses the regeneration key bit segment sequence group identifier (bsk1 i,q 、bsk2 i,q 1, 2, see the error segment overlay logic structure 4.5) and the regeneration key bit segment sequence sub-marker in the group (bsk1 i,q 、bsk2 i,q The q in (see the segment overlay logic structure 4.5) is merged into '1' or '2', and a single buffer area is used instead of the stack.

[0366] Calculation parameters and calculation formula of Example 2

[0367] Chaos computing structure configuration

[0368] The same chaotic computing structure configurations 1 to 6 as in Example 1.

[0369] Encryption / decryption calculation formula and calculation unit of embodiment 2

[0370] 7 is the same as the encryption / decryption calculation formula and calculation unit 7 of embodiment 1.

[0371] 8 is the same as the encryption / decryption calculation formula and calculation unit 8 in Example 1.

[0372] 9 pseudo-randomly construct the regeneration key bit segment of the first regeneration key bit segment sequence bsk1 :

[0373] 9.1 Define the construction source of the first regeneration key bit sequence pickarea1 i The construction byte in pickbyte1 i,j (The calculation formula is in bytes)

[0374] 9.1.1 Define the construction source of the first regeneration key bit sequence pickarea1i

[0375] 9.1.1.1 Define the construction source of the first regeneration key bit segment sequence at the starting byte position in the working pool SPool work :

[0376] pickarea1start0 = vector0 % workbyte(14)

[0377] pickarea1start i =(pickarea1start i-1 + 1) % workbyte(14’)

[0378] (14) is the starting byte position of the first-round construction source in the working pool SPool work , (14’) is the starting byte position of the construction source in other rounds in the working pool SPool work .

[0379] 9.1.1.2 Define the construction source pickarea1 of the first regeneration key bit segment sequence i :

[0380]

[0381] (15) is the construction source composed of ls i bytes starting from pickarea1start i (h advancing in bytes and continuing from the head when reaching the end of the working pool).

[0382] 9.1.2 Define the construction byte sequence pickbyte1 of the first regeneration key bit segment sequence i,j , j = 0, 1,..., ls i - 1:

[0383] pickbyte1 i,j = pickarea1 i (pos_chain(ls i - L min , j)) % workbyte, j = 0, 1,..., ls i - 1 (16)

[0384] Where: pos_chain(ls i - L min , j) is the j-th position element in the position chain pos_chain(ls i - L min ) with the same length as the bit segment length.

[0385] 9.2 The encryption / decryption calculation formula and calculation unit 9.2 are the same as those in Embodiment 1.

[0386] 9.3 Construct the regeneration key segment of the first regeneration key segment sequence bsk1 i

[0387] 9.3.1 Extract the first control value pickdriveval1 from the first control element pickdrivelmt1 of the first regeneration key segment sequence i,0 according to the encryption / decryption calculation formula in Embodiment 1 and the method of calculation unit 9.2.3, and clear the output pseudo-random string tmp_str(j), j = 0, 1,..., ls i,0 - 1. i -1.

[0388] 9.3.2 Extract the value from the current construction byte pickarea1 i (j) according to the bit position specified by the current control value pickdriveval1 i,j to update the element tmp_str(j) in the output pseudo-random string.

[0389] 9.3.3 Move the current control element pickdrivelmt1 i,j backward by 4 bits as the next control element pickdrivelmt1 i,j+1 , and locate to the next construction byte according to (16).

[0390] 9.3.4 Extract the next control value pickdriveval1 according to the encryption / decryption calculation formula in Embodiment 1 and the method of calculation unit 9.2.3 i,j .

[0391] 9.3.5 Step j = j + 1, and repeat the above 9.3.2, 9.3.3, 9.3.4 until j = ls i - 1 to obtain the output pseudo-random string tmp_str(j), j = 0, 1,..., ls i - 1.

[0392] 9.3.6 Rearrange the pseudo-random bit positions according to the output pseudo-random string tmp_str(j), j = 0, 1,..., ls i - 1, and use the result as the regeneration key segment of the first regeneration key segment sequence bsk1 i .

[0393] 10 The encryption / decryption calculation formula and calculation unit 10 are the same as those in Embodiment 1 (the metabolic target is the metabolic target area of the first regeneration key segment sequence).

[0394] 11 The encryption / decryption calculation formula and calculation unit 11 are the same as those in Embodiment 1.

[0395] 12 Secondary regeneration key bit segment sequence of the pseudo-random structure, Example 2, regeneration key bit segment bsk2 i

[0396] 12.1 Determine the construction source pickarea2 of the secondary regeneration key bit segment sequence of Example 2 i and the control source pickdrivearea2 i

[0397] 12.1.1 Pseudo-randomly determine the starting position of the construction source of the secondary regeneration key bit segment sequence by the dynamic drive vector vector i : pickstart2 i,0 = vector i [2] % length(Spool work )

[0398] 12.1.2 The construction source pickarea2 i is composed of the bit string from the construction source starting position pickstart2 i,0 to the end of the selection pool and the two bit strings from the beginning of the selection pool to before the construction source starting position pickstart2 i,0 concatenated together.

[0399] 12.1.3 Pseudo-randomly determine the starting position of the control source of the secondary regeneration key bit segment sequence by the dynamic drive vector vector i : pickdrivstart2 i,0 = (pickstart2 i,0 + length(Spool work ) - vector i [4] - 1) % length(Spool work )

[0400] 12.1.4 The control source pickdrivearea2 i is composed of the bit string from the control source starting position pickdrivstart2 i,0 to the end of the selection pool and the two bit strings from the beginning of the selection pool to before the control source starting position pickdrivstart2 i,0 concatenated together.

[0401] 12.2 Starting from the control source starting position pickdrivstart2 i,0 sequentially (continuing from the end of the working pool and resuming from the beginning) extract ls i with a length of log2(workbyte * 8 / l maxThe bit string of ))+1 constitutes the bit jump value sequence jump2_num(j), where j = 1, 2,..., ls i -1.

[0402] 12.3 Let j = 0 and clear the output pseudo-random string tmp_str(j), where j = 0, 1,..., ls i -1.

[0403] 12.4 Use the formula pickbit0 = pickstart2 i,0 , pickbit j = (pickbit j-1 + jump2_num(j)) % length(Spool work ), where j = 1,…, ls i -1, to obtain the bit strings pickbit i in the ls j construction sources, where j = 0, 1,..., ls i -1, and extract the values of each bit to form the output pseudo-random string tmp_str(j), where j = 0, 1,..., ls i -1.

[0404] 12.5 Use the method of the single complex reconstruction logic structure 1.5.3 to perform pseudo-random bit rearrangement on the output pseudo-random string tmp_str(j), where j = 0, 1,..., ls i -1 to obtain the regeneration key segment of the secondary regeneration key bit segment sequence bsk2 i .

[0405] 13 Extracted Bit Metabolism Logic

[0406] 13.1 In 12.4, retain each pickbit j , where j = 0, 1,..., ls i -1 as the extracted bit metabolism target area.

[0407] 13.2 Use the position chain pos_chain(ls i -L min , j) (where j = 0, 1, 2,..., ls i -1) to perform pseudo-random bit conversion on the output pseudo-random string tmp_str(j) obtained in 12.4, where j = 0, 1,…, ls i -1 to obtain the metabolic source pseudo-random string metabol_str(j) (where j = 0, 1, 2,…, ls i -1):

[0408]

[0408] 13.2.1 Define the same as the regeneration key segmentbsk2 i Metabolite source pseudo-random strings of equal length metabol_str(j) (j = 0, 1, 2,..., ls i -1).

[0409] 13.2.2 If the position chain pos_chain(ls bsk2 i of equal length to the regeneration key bit segment i -L min ) has pos_chain(ls i -L min , 0) = 0, then the metabolite source pseudo-random string metabol_str(j) = 0, (j = 0, 1, 2,..., ls i -1); if the position chain pos_chain(ls i -L min ) of equal length to the regeneration key bit segment has pos_chain(ls i -L min , 0) = ls i -1, then the metabolite source pseudo-random string metabol_str(j) = 1, (j = 0, 1, 2,..., ls i -1).

[0410] Otherwise

[0411] 13.2.3 After swapping the values of the corresponding bits at the positions specified by the position elements in the position chain one by one in the output pseudo-random string, splice the metabolite source pseudo-random string metabol_str(j) = tmp_str[pos_chain(ls -L i -L min , j)], (j = 0, 1, 2,..., ls i -1).

[0412] 13.3 For each metabolite source pseudo-random string metabol_str(j) (j = 0, 1, 2,..., ls i -1), metabolize the extracted bit metabolic target bit (i.e., the extracted bit) pickbit j , j = 0, 1,..., ls i -1: pickbit i (j) = metabol_str(j) (j = 0, 1, 2,..., ls i -1).

[0413] 14 Determine that the bit segment cut value is (1 / 2)L min , and set the cut formula

[0414] 14.1 Length of the upper half segment of the first regeneration key segment sequence and the lower half segment of the second regeneration key segment sequence: L1f i = L2l i = (1 / 2)L min ;

[0415] Length of the lower half segment of the first regeneration key segment sequence and the upper half segment of the second regeneration key segment sequence: L1l i = L2f i = ls i - (1 / 2)L min .

[0416] So there is:

[0417] 14.2 Labels of the split half segments (or half sections) (see Figure 8 ):

[0418] Plaintext first / second half segment Mf i , Ml i , (plaintext first and second half segments)

[0419] First key first / second half segment K1f i , K1l i , (first and second half segments of the regeneration key segment of the first regeneration key segment sequence)

[0420] Second key first / second half segment K2f i , K2l i , (first and second half segments of the regeneration key segment of the second regeneration key segment sequence)

[0421] First transition first / second half segment T1f i , T1l i , (first and second half segments after encryption of the first regeneration key segment sequence)

[0422] Twisted transition first / second half segment T1f i X, T1l i X, (first and second half segments after encryption of the first regeneration key segment sequence and implementing pseudo-random bit twisting)

[0423] Second transition first / second half segment T1f i X2l i-1 , T1l i X2f i (first and second half segments after encryption with the second regeneration key segment sequence after implementing pseudo-random bit twisting)

[0424] Ciphertext first / second half segment Cf i , Cl i , (ciphertext first and second half segments)

[0425] Encryption / Decryption Process Control of Embodiment 2

[0426] In this embodiment, the pseudo-random bit wrapping is only embedded once, so the stacks used for reverse processing (stack_k2f, stack_k2l, s_stack_k2l, stack_bsk1, stack_chain, see Figure 8’-2 ) are omitted.

[0427] Encryption

[0428] 1 Configure the control quantity ctl of the chaotic computing structure according to the above, and make the structure configuration quantity ctl init = 640.

[0429] 2 Construct the dynamic drive vector vector0, select the pool Spool, the working pool SPool according to the chaotic computing structure configuration above work , the maximum value L of the bit segment length limit max , the minimum value L of the bit segment length limit min , the pseudo-plaintext pM, the plaintext end symbol EOP, and the position chain set pos_chain.

[0430] 3 Generate the encrypted plaintext M = pM||plaintext||EOP||ms according to the encryption / decryption calculation formula and calculation unit of Embodiment 2 additn ; Calculate the bit segment length ls0.

[0431] 4 Extract the plaintext bit segment M0 (Mf0||Ml0) with a length of the bit segment length ls0 from the encrypted plaintext M.

[0432] 5 Construct the first regeneration key segment of the first regeneration key segment sequence of the encryption / decryption calculation formula and calculation unit 9 of Embodiment 2 bsk10 (K1f0||K1l0). Construct the first regeneration key segment of the second regeneration key segment sequence of the encryption / decryption calculation formula and calculation unit 12 of Embodiment 2 bsk20 (K2f0||K2l0). Perform the growth metabolism on the working pool with the plaintext bit segment M0 (i.e., the pseudo-plaintext pM0) (see the single complex reconstruction logic structure 1.5.5.1).

[0433] 6 Perform the metabolism of the position chain pos_chain (ls0 - L min ) according to the encryption / decryption calculation formula and calculation unit 11 of Embodiment 2.

[0434] 7 Store the second half k2l0 of the first regeneration key segment of the second regeneration key segment sequence bsk20 into the cache queue2l.

[0435] 8 Use the first regeneration key segment of the first regeneration key segment sequence bsk10XOR encrypt the plaintext bit segment M0 to generate the first transitional bit segment T1f0||T1l0.

[0436] 9 Pseudorandomly bit-wrap the first transitional bit segment T1f0||T1l0 with the position chain pos_chain(ls0-L min ) to generate the rearranged transitional bit segment T1f0X||T1l0X.

[0437] 10 According to the encryption / decryption calculation formula and calculation unit 11 of Embodiment 2, metabolize the position chain pos_chain(ls i -L min ).

[0438] 11 Encrypt the rearranged transitional second half bit segment T1l0X with the second half bit segment K2f0 of the secondary key to generate the secondary transitional second half bit segment T1l0X2f0.

[0439] 12 i = i + 1, calculate the next ls i .

[0440] 13 Extract the dynamic drive vector vector i , and sequentially extract the plaintext bit segment M of length ls i from the encrypted plaintext M i .

[0441] 14 Copy queue2l into q_queue2l and clear queue2l.

[0442] 15 Construct the regeneration key segment of the first regeneration key segment sequence according to the encryption / decryption calculation formula and calculation unit 9 of Embodiment 2 bsk1 i (K1f i ||K1l i ), if the work pool reaches maturity, then perform sequential extraction bit metabolism using the extracted output pseudorandom string according to the encryption / decryption calculation formula and calculation unit 10 of Embodiment 2; construct the regeneration key segment of the second regeneration key segment sequence according to the encryption / decryption calculation formula and calculation unit 12 of Embodiment 2 bsk2 i (K2f i ||K2l i ), if the work pool reaches maturity, then perform the extracted bit metabolism using the extracted output pseudorandom string according to the encryption / decryption calculation formula and calculation unit 13 of Embodiment 2. If the work pool does not reach maturity, then perform growth period metabolism on the work pool with the plaintext bit segment M i (i.e., the pseudoplaintext pM i ) (see the single complex reconstruction logic structure 1.5.5.1).

[0443] 16 Perform the position chain pos_chain(ls according to the encryption / decryption calculation formula and calculation unit 11 of Embodiment 2i -L min ) Metabolism.

[0444] 17 The regeneration key segment of the first regeneration key segment sequence bsk1 i For M i Calculate the first transition segment T1f i ||T1l i .

[0445] 18 For the first transition segment T1f i ||T1l i With the position chain pos_chain(ls i -L min )'s position order to perform pseudo-random bit wrapping to generate the wrapped transition segment T1f i X||T1l i X.

[0446] 19 For the position chain pos_chain(ls i -L min ) Metabolism.

[0447] 20 Extract the second half k2l of the regeneration key segment of the previous round from the cache q_queue2l i-1 , misaligned recombination of the regeneration key segment k2l i-1 ||k2f i , and use it to encrypt T1f i X||T1l i X to generate the misaligned secondary transition segment T1f i X2l i-1 ||T1l i X2f i (i.e., the ciphertext segment of this embodiment).

[0448] 21 Store the second half k2l of the regeneration key segment of the secondary regeneration key segment sequence generated in this round i into the cache queue2l.

[0449] 22 i = i + 1, calculate the next ls i , and make a loop condition judgment:

[0450] 22.1 If ls i is greater than the length of the unencrypted plaintext, then perform post-encryption processing 23 and end the calculation.

[0451] 22.2 Otherwise, execute 13 to 22 to perform the next round of misaligned superposition calculation with embedded pseudo-random bit wrapping until the condition in 22.1 is satisfied.

[0452] 23 Append the unencrypted remaining plaintext in 22.1 to the end of the ciphertext.

[0453] Decryption

[0454] Since the pseudo-random bit winding process is embedded in the encryption process, the decryption process must be completed after extracting the regenerated key segment and unwinding the pseudo-random bit position chain pos_chain (ls i -L min ) and then processed in reverse order of encryption:

[0455] 1 Same as encryption process 1 and 2, configuration structure control quantity: dynamic drive vector vector0, selection pool Spool, working pool SPool work , the bit segment length limits the maximum value L max , the bit segment length is limited to the minimum value L min , pseudo-plaintext pM length, plaintext end character EOP, position chain set pos_chain.

[0456] 2 Let i=0 and calculate the bit segment length ls0.

[0457] 3 Extract the ciphertext bit segment C0 (Cf0||Cl0) with a length of bit segment length ls0 from the ciphertext C.

[0458] 4. Construct the regeneration key bit segment of the first regeneration key bit segment sequence bsk10 (K1f0||K1l0); construct the regeneration key bit segment of the secondary regeneration key bit segment sequence bsk20 (K2f0||K2l0). The working pool is metabolized during the growth period using the plaintext bit segment M0 (ie, pseudo-plaintext pM0) (see single complex reconstruction logic structure 1.5.5.1).

[0459] 5 According to the encryption / decryption calculation formula of embodiment 2 and the calculation unit 11, the position chain pos_chain (ls i -L min )metabolism.

[0460] 6 Store the second half k2l0 of the regenerated key bit segment of the secondary regenerated key bit segment sequence into stack_k2l.

[0461] 7 XOR the ciphertext second half segment Cl0 with the secondary key first half segment k2f0 to obtain the transition second half segment T1l0X that was rearranged during encryption.

[0462] 8 Use T1l0X obtained in 7 to concatenate with the first half of the ciphertext segment Cf0 to obtain the rearranged transition segment T1f0X||T1l0X, and use the position chain pos_chain(ls0-L min ) are pseudo-randomly unwrapped in bit order to obtain the first transition bit segment T1f0||T1l0.

[0463] 9 pairs of position chains pos_chain(ls0-L min ) metabolism.

[0464] 10 Use the regeneration key segment of the first regeneration key segment sequence bsk10 to decrypt the obtained transition segment T1f0||T1l0 to obtain the plaintext segment Mf0||Ml0.

[0465] 11 i = i + 1, and calculate ls i , extract the dynamic drive vector vector i .

[0466] 11.1 If ls i is greater than the length of the unencrypted plaintext, perform post-processing after 22 decryption.

[0467] 11.2 Otherwise, extract the ciphertext segment C with a length of ls i from the ciphertext C i (Cf i ||Cl i ).

[0468] 12 Copy stack_k2l to s_stack_k2l and clear stack_k2l.

[0469] 13 Construct the regeneration key segment of the first regeneration key segment sequence according to the encryption / decryption calculation formula and calculation unit 9 of Embodiment 2 bsk1 i (K1f i ||K1l i ), if the working pool reaches maturity, perform postponed bit metabolism using the extracted output pseudo-random string according to the encryption / decryption calculation formula and calculation unit 10 of Embodiment 2; construct the regeneration key segment of the secondary regeneration key segment sequence according to the encryption / decryption calculation formula and calculation unit 12 of Embodiment 2 bsk2 i (K2f i ||K2l i ), if the working pool reaches maturity, perform extracted bit metabolism using the extracted output pseudo-random string according to the encryption / decryption calculation formula and calculation unit 13 of Embodiment 2.

[0470] 14 Perform metabolism of the position chain pos_chain(ls i -L min ) according to the encryption / decryption calculation formula and calculation unit 11 of Embodiment 2.

[0471] 15 Store the second half k2l of the regeneration key segment of the secondary regeneration key segment sequence i into stack_k2l.

[0472] 16 Recombine the regeneration key segment k2l i-1 ||k2fi , and then perform decryption calculation on the ciphertext bit segment C i (Cf i ||Cl i ) to obtain the rearranged intermediate bit segment T1f i X||T1l i X.

[0473] 17 Use the position chain pos_chain(ls i -L min ) to remove the pseudo-random bit wrapping of T1f i X||T1l i X to obtain the first intermediate bit segment T1f i ||T1l i .

[0474] 18 Metabolize the position chain pos_chain(ls i -L min ).

[0475] 19 Use the regeneration key segment of the regeneration key segment sequence of the first regeneration key bit segment bsk1 i to decrypt the obtained first intermediate bit segment T1f i ||T1l i to obtain the plaintext bit segment Mf i ||Ml i .

[0476] 20 If the working pool has not reached maturity, use the plaintext bit segment M i (i.e., the pseudo-plaintext pM i ) to perform growth period metabolism on the working pool (see the single complex reconstruction logic structure 1.5.5.1).

[0477] 21 Repeat steps 11 to 20 for the next round of decryption calculation with embedded pseudo-random bit wrapping until ls i is greater than the length of the undecrypted ciphertext.

[0478] 22 Post-decryption processing

[0479] 22.1 Remove the pseudo-plaintext pM from the decrypted plaintext.

[0480] 22.2 Check whether the end-of-plaintext symbol EOP in the decrypted plaintext is correct. If the end-of-plaintext symbol EOP is correct, remove the end-of-plaintext symbol EOP and the subsequent padding pseudo-random string ms additn ; if the end-of-plaintext symbol EOP is incorrect, it indicates an error occurred during the encryption, transmission, and decryption processes.

[0481] Description of the invention features

[0482] 1. The security is fully guaranteed by implementing misaligned superposition encryption with an infinite non-repeating regenerative key bit sequence construction mechanism. Since the underlying loop mainly calculates in bit units, the implementation speed of the present invention can also be guaranteed.

[0483] 2. Compared with traditional sequence encryption methods, the present invention can configure corresponding encryption models according to the needs of application forms, and has a wider application range. And it has a certain adjustable space and integration space with other methods.

[0484] 3. Since the structural configuration quantity can be adjusted according to needs, the present invention can adapt to the growing security needs of computing power. It can be proved that: except for brute-force attacking the key, there is no attack algorithm with polynomial time complexity for cracking the key, that is, the present invention provides an example of P < nP.

[0485] It can be understood that for those skilled in the art, equivalent replacement, change or simplification of the technical solution and inventive concept of the present invention should all fall within the protection scope of the appended claims of the present invention.

Claims

1. A sequence encryption method for complex reconstructed keys, characterized in that: Generate a structure manipulation quantity using a key and a structure configuration quantity, and use the structure manipulation quantity to manipulate the composite logic supporting the chaotic computing structure scheduling to achieve chaotic bit-stream sequence encryption for bit fields; pseudo-randomly reconstruct the construction source and the manipulation source round by round and use the manipulation source to pseudo-randomly manipulate the construction source to reconstruct and regenerate key bit fields; use the integration of more than one sequence of regenerated key bit fields to achieve cross-segment winding between different sequences of regenerated key bit fields; use pseudo-random bit winding to achieve cross-segment winding between the front and back bit fields that is not related to the cross-segment winding between sequences of regenerated key bit fields; the core of the invention includes three closely related calculations: (A) Construct a chaotic computing structure, metabolize the working pool segment by segment during the encryption process, and then use the bits in the manipulation source to manipulate the bit extraction logic in the construction source segment by segment to extract bits from the construction source, and pseudo-randomly reconstruct and regenerate key bit fields; (B) Based on the chaotic computing structure, integrate the bit extraction logic and the bit metabolism logic to construct an infinite non-cyclic construction logic for regenerated key bit fields that "pseudo-randomly misaligns to extract the bits of the construction source that have not been metabolized or redundantly extracts the bits of the construction source that have been metabolized"; (C) Based on the chaotic computing structure, perform cross-segment superposition encryption on more than one different sequence of regenerated key bit fields; The technical solution includes: (1) Construct a chaotic computing structure from a key through a computing structure configuration quantity to support bit-by-bit sequence encryption that pseudo-randomly determines the calculation parameters for each segment; (2) Load the initial working pool with the key to lead the chaotic encryption process of bit-by-bit logical winding; (3) Use the pseudo-plaintext extended working pool independently constructed by the encrypting party to further chaotic encrypt the process and increase the safety threshold; (4) Establish a round-by-round metabolism mechanism for the working pool, and configure the bit extraction logic and the bit metabolism logic accordingly to establish a construction logic for regenerated key bit fields that "pseudo-randomly misaligns to extract the bits of the construction source that have not been metabolized or redundantly extracts the bits of the construction source that have been metabolized"; (5) Use the chaotic computing structure to eliminate the periodic law that may appear in the constructed sequence of regenerated key bit fields; (6) Use different construction sources, manipulation sources, bit extraction logics, and bit metabolism logics to construct different sequences of regenerated key bit fields, and based on the chaotic computing structure, achieve cross-segment superposition encryption with embedded pseudo-random bit winding for different sequences of regenerated key bit fields; (7) Establish a plaintext end marker based on the key to resolve the misalignment between the plaintext end position and the segmented calculation end position and use the plaintext end marker as a verification code for the correctness of the decryption calculation.

2. The sequence encryption method for complex reconstructed keys according to claim 1, characterized in that: Configure a structure manipulation quantity from a key through a structure configuration quantity to manipulate chaotic variable-length segmented encryption calculations: (1) Use the key key in combination with the structure configuration quantity ctl init Configure the length of the selection pool Spool, the initial working pool Spool work The length of; (2) Determine the extraction position of the initial dynamic drive vector vector0 in the working pool Spool pseudo-randomly according to the key work ; (3) Determine the length of the pseudo-plaintext pM according to the length of the selection pool Spool and the length of the key; (4) Pseudorandomly determine the maximum value L of the bit segment length limit according to the initial dynamic drive vector vector0 max and the minimum value L of the bit segment length limit min ; (5) Generate the plaintext end marker EOP according to the initial dynamic drive vector vector0 and other bit strings in the key; (6) Limit the maximum value L according to the bit segment length max and limit the minimum value L of the bit segment length min Construct a position chain set pos_chain; (7) Concatenate the pseudo-plaintext pM, the plaintext plaintext, and the end-of-plaintext symbol EOP, and append a padding pseudo-random string ms max with a length of L additn , and reconstruct the plaintext M for calculation; (8) Use the structure manipulation quantity obtained from the above (1) to (6) to manipulate the chaotic computing structure to encrypt the reconstructed plaintext M.

3. The sequence encryption method for complex reconstructed keys according to claim 1, characterized in that: Initial load the working pool SPool using the key key work , and start the construction process of the regenerated key bit segment sequence.

4. The sequence encryption method for complex reconstructed keys according to claim 1, characterized in that: A pseudo-plaintext pM extended working pool SPool that is independently constructed by the encryption party and has nothing to do with the plaintext content work ; Furthermore, the key key and the pseudo-plaintext pM jointly lead the process of reconstructing and regenerating the key bit sequence to improve the safety threshold.

5. The sequence encryption method for complex reconstructed keys according to claim 1, characterized in that: Use the bit metabolism logic to metabolize the working pool SPool round by round according to the configuration of the computing structure work , and then use the control source to control the bit extraction logic to extract the bit values of the construction source, so as to realize the per-bit reconstruction and regeneration key bit segment logic of "pseudo-random dislocation extraction of unmetabolized construction source bit positions or duplicate bit extraction of metabolized construction source bit positions". (1) Implement working pool metabolism with bit metabolism logic and reconstruct and regenerate key bit fields from the working pool with bit extraction logic; (2) Enumerated bit extraction logic: (2.1) Progressive carry logic; Pseudo-randomly determine the starting byte pickstart of the first-round constructed source in the working pool with the initial dynamic drive vector vector0 0,0 ; Pseudo-randomly obtain the relative bit difference dif with the initial dynamic drive vector vector0, where dif < length(Spool work ), and determine the starting position pickdrivstart of the first-round control source in the working pool 0,0 = (pickstart 0,0 + length(Spool work ) - dif) % length(Spool work ); Progress one byte at a time until reaching the working pool Spool work After reaching the end, continue from the beginning to determine each subsequent round: ① Construct the source start byte pickstart i,0 =(pickstart i-1,0 +8) % length(Spool work ), ② Control the source start position pickdrivstart i,0 =(pickdrivstart i-1,0 +8) % length(Spool work ); Use the ls bytes starting from the construction source start byte in the work pool i as the byte segment of the construction source pickarea for each round i ; Use the bit string composed of n times of ls starting from the starting position of the manipulation source in the work pool as the manipulation source pickdrivearea i where n is 3 or 4 or 8; i n is 3 or 4 or 8; Using the control source pickdrivearea i In the i , a sequence of bit strings composed of every 3 or 4 or 8 bits in sequence forms a control element sequence, and 3 bits in each control element are extracted as control values to form a control value sequence pickdriver i (j), where j = 0, 1, 2,..., ls i -1; Pair the manipulation values in the manipulation value sequence and the construction bytes pickdriver in the construction source sequentially i (j) / pickarea i (j), where j = 0, 1, 2,..., ls i -1; Pairwise, use the value of the bit of the constructed byte specified by the control value as the output bit value, and concatenate the output pseudo-random string tmp_str(j), where j = 0, 1, 2,..., ls i -1; Using the constructed output pseudo-random string tmp_str(j), where j = 0, 1, 2, …, lsi-1, or performing a pseudo-random bit rearrangement on it as the regenerated key bit segment bsk i ; (2.2) Progressive chain extraction logic; When configuring the chaotic computing structure, the maximum value L is limited by the bit segment length max and the minimum value L of the bit segment length min Construct a position chain set pos_chain and initialize it with a key; Pseudo-randomly determine the starting byte pickstart of the first-round construction source with the initial dynamic drive vector vector0 in the working pool 0,0 ; Pseudo-randomly obtain the relative bit difference dif with the initial dynamic drive vector vector0, where dif < length(Spool work ), and determine the starting position pickdrivstart of the first-round control source in the working pool 0,0 = (pickstart 0，0 + length(Spool work ) - dif) % length(Spool work ); Progress one byte at a time until reaching the working pool Spool work After reaching the end, continue from the beginning to determine in subsequent rounds: ① the starting byte pickstart of the construction source i,0 =(pickstart i-1,0 +8)% length(Spool work ), ② the starting bit pickdrivstart of the control source i,0 =(pickdrivstart i-1,0 +8)% length(Spool work ); Use the ls bytes starting from the construction source start byte in the work pool i as the construction source pickarea for the byte segment consisting of these bytes i ; Take the ls starting from the starting position of the manipulation source in the working pool i The n, where n is 3 or 4 or 8, times of bits composed of a bit string as the manipulation source pickdrivearea i ; Using the control source pickdrivearea i In it, a bit string composed of every 3 or 4 or 8 bits in sequence is used as a control element to form a control element sequence, and 3 bits in the control element are extracted as a control value to form a control value sequence pickdriver i (j), where j = 0, 1, 2,..., ls i -1; Pair the manipulation values in the manipulation value sequence and the construction bytes pickdriver i -L min ) in the construction source determined by the position element pos_chain(ls i -L min ,j) sequentially, where j = 0, 1, 2,..., ls i (j) / pickarea i (pos_chain(ls i -L min ,j)), j = 0, 1, 2,..., ls i -1; Take the value of the bit in the constructed byte specified by the manipulation value pair by pair as the output bit value, and splice the output pseudo-random string tmp_str(j), where j = 0, 1, 2, …, ls i -1; Using the constructed output pseudo-random string tmp_str(j), where j = 0, 1, 2,..., ls i -1 or perform pseudo-random bit rearrangement on it and then use it as the regenerated key bit segment bsk i ; (2.3) Bit jump extraction logic; With a dynamic drive vector vector i Pseudo-randomly determine the starting position pickstart of the construction source for each round i,0 , and use the starting position pickstart of the construction source i,0 The bits string from the starting position pickstart of the construction source to the end of the working pool and the bits string from the head of the working pool to the starting position pickstart of the construction source i,0 Before splicing to construct the source pickarea i ; With the dynamic drive vector vector i Pseudo-randomly obtain the relative bit difference dif, dif ≤ length(Spool work ), determine the starting position pickdrivstart of each round of control source in the working pool i,0 =(pickstart i,0 + length(Spool work ) - dif) % length(Spool work ), and use the bits string from the control source starting position pickdrivstart i,0 to the end of the working pool and the bits string from the head of the working pool to before the control source starting position pickdrivstart i,0 to splice the control source pickdrivearea i ; Extract ls from the control source either by jumping or not jumping i Fixed-length bit substrings are used as bit jump values to form a bit jump value sequence junp_num(j), where j = 0, 1, 2,..., ls i - 1, and continue from the beginning after reaching the end of the working pool; One by one, j = 0, 1, 2,..., ls i -1, skipping from the construction source at intervals of each bit jump value in the bit jump value sequence, continuing from the beginning after reaching the end of the working pool, determining the extracted bit, and concatenating its value to output the pseudo-random string tmp_str(j), where j = 0, 1, 2,..., ls i -1; Use the constructed output pseudo-random string tmp_str(j), where j = 0, 1, 2,..., ls i -1 or perform pseudo-random bit rearrangement on it and then use it as the regenerated key bit segment bsk i ; (2.4) Sequential promotion extraction logic: The starting byte pickstart0 of the first-round constructed source is pseudo-randomly determined by the initial dynamic drive vector vector0; subsequently, the starting byte pickstart of each round of the constructed source i is shifted by one byte round by round. When the shift reaches the end of the working pool, it continues from the beginning. pickstart i = (pickstart i-1 + 8) % length(Spool work ); Pick area of the structure source in each round i Composed of ls bytes starting from the pick start byte of the structure source i Starting from the pick start byte and continuing sequentially i When reaching the end of the working pool, continue from the beginning; Let the above-mentioned construction source be pickarea i The extracted bit of the first construction byte in i is the 0th bit. The extracted bit of the subsequent construction bytes increases by one bit byte by byte. After reaching 7, it continues from 0. The values of the extracted bits of the construction bytes are sequentially concatenated to output the pseudo-random string tmp_str(j), where j = 0, 1, 2,..., ls i -1; Use the constructed output pseudo-random string tmp_str(j), where j = 0, 1, 2,..., ls i -1 or perform pseudo-random bit rearrangement on it After that, it is used as the regenerated key bit segment bsk i ; (3) Enumerated bit metabolism logic and its related metabolism: (3.1) For the working pool SPool during the growth period where length(SPool work ) < length(SPool): work Metabolism: When length(Spool) - length(Spool work ) ≥ ls i At this time, during encryption, append or pseudo-randomly insert a pseudo-plaintext substring pM i with a length of ls i sequentially extracted from the plaintext into the working pool SPool work and maintain the working pool SPool work The length length(Spool work ) = length(Spool work ) + ls i ; During decryption, append or pseudo-randomly insert a pseudo-plaintext substring pM i with a length of ls i extracted from the decrypted plaintext into the working pool SPool work and maintain the working pool SPool work The length length(Spool work ) = length(Spool work ) + ls i ; When length(Spool) - length(Spool work ) < ls i At that time, during encryption, append or pseudo-randomly insert a pseudo-plaintext substring pM work with a length of length(Spool) - length(Spool i ) sequentially extracted from the plaintext into the working pool SPool work And let length(Spool work ) = length(Spool); during decryption, append or pseudo-randomly insert a pseudo-plaintext substring pM work with a length of length(Spool) - length(Spool i ) extracted from the decrypted plaintext into the working pool SPool work And let length(Spool work ) = length(Spool); the working pool reaches maturity; (3.2) For the working pool SPool where length(SPool work ) = length(SPool), work During the mature period, use the bit metabolic logic to metabolize the working pool: (3.2.1) Sequential promotion metabolism logic: Pickdrivstart from the manipulation source starting position in the working pool i,0 Select ls i A metabolic target area metabolarea consisting of i ; Shifted metabolic target area metabolarea i Shift one byte backward in each round in the working pool. When reaching the end of the working pool, continue from the beginning; Use the position chain pos_chain(ls i -L min ) to perform pseudo-random bit conversion on the original metabolic source random string, that is, the output pseudo-random string tmp_str(j) of the bit-taking logic of any bit, where j = 0, 1, 2,..., ls i -1 , where the pseudo-random bit rearrangement must be different from the pseudo-random bit rearrangement when constructing the regenerative key bit segment to obtain the metabolic source random string metabolsrc i (j), where j = 0, 1, 2,..., ls i -1; Set in the postponed bit - shifted metabolic target area metabolarea i The metabolic bit in the first byte is the 0th bit, and then each subsequent byte increases by one bit. After reaching 7, it continues from 0. As the metabolic bit of each byte in the postponed bit - shifted target area, the metabolic bit sequence metabolbit is obtained i (j), where j = 0, 1, 2,..., ls i -1; Sequentially by bit, with a random string of metabolic sources metabolsrc i (j), where j = 0, 1, 2, ..., ls i Replace the value of the bit of -1 with the value of the corresponding metabolic bit of the byte in the shifted target area i (j) = metabolsrc i (j), where j = 0, 1, 2, ..., ls i -1; (3.2.2) Extracted bit metabolism logic: Construct a pseudo-random string tmp_str(j) at any bit-taking logic output, where j = 0, 1, 2,..., ls i When it is -1, sequentially concatenate its bits as the extracted bit sequence pickedbit i (j), where j = 0, 1, 2,…, ls i -1; Use the position chain pos_chain(ls i -L min ) to perform pseudo-random bit conversion on the original metabolic source pseudo-random string, that is, the output pseudo-random string tmp_str(j) of the bit-taking logic for any bit, where j = 0, 1, 2,..., ls i -1 Among them, the pseudo-random bit rearrangement must be different from the pseudo-random bit rearrangement when constructing the regenerative key bit segment to obtain the metabolic source pseudo-random string metabolsrc i (j), where j = 0, 1, 2,..., ls i -1; Implement the extracted bit metabolism pickedbit i (j) = metabolsrc i (j), j = 0, 1, 2,..., ls i -1; (3.3) Utilize the randomness of the secret key to implement the position chain pos_chain(ls i -L min ) Metabolism: Create an empty transitional position chain tmp_chain with a length of (1 / 2)length(vector i ) - 1; Sequential extraction of dynamic drive vector vector i The value represented by every two bits is used as a jump value to obtain a jump value sequence rp j , j = 0, 1, ..., min((1 / 2)length(vector i ) - 1, ls i - 1); Let p0 = rp0, p j = p j-1 + rp j + 1, Calculation: ① tmp_chain(j) = pos_chain(ls i -L min ,p j ) and ② remove the position element pos_chain(ls i -L min ,p j ), j = 0, 1, ..., (1 / 2)length(vector i ) - 1; thus, part or all of pos_chain(ls i -L min ) is pseudo-randomly imported into tmp_chain; When (1 / 2) length (vector i ) < ls i ), append the (1 / 2) length (vector i ) position elements generated in the new position chain tmp_chain to the end of the compressed position chain pos_chain (ls i -L min ); when (1 / 2) length (vector i ) ≥ ls i ), replace the used position chain pos_chain (ls i -L min ) with the new position chain tmp_chain; (3.4) For the dynamic drive vector vector i Metabolize by one of the following two (3.4.1) Implement the dynamic drive vector vector by shifting one byte backward in the working pool round by round i Metabolism; (3.4.2) Round by round, use the equal-length bit strings in the working pool that are different from the dynamic drive vector vector in the previous round to perform exclusive OR with the dynamic drive vector vector in the previous round i-1 to generate a new vector i-1 ; i ; (4) Rearrange the pseudo-random bit positions of the output pseudo-random string before generating the regenerated key bit segment , perform pseudo-random bit conversion on the original metabolic source pseudo-random string, that is, the output pseudo-random string tmp_str(j) of any bit extraction logic, j = 0, 1, 2, ..., ls i - 1, before the working pool metabolism : (4.1) Based on the randomness of the position chain pos_chain(ls i -L min ), the output pseudo-random string tmp_str(j), j = 0, 1, 2,..., ls i -1 obtained by the bit-taking logic is used to achieve pseudo-random bit rearrangement ; (4.2) Based on the randomness of the position chain pos_chain(ls i -L min ), the pseudo-random string of the original metabolic source is realized, that is, the output pseudo-random string tmp_str(j) of the bit-taking logic for any bit, where j = 0, 1, 2,..., ls i -1, for pseudo-random bit conversion , including: (4.2.1) Based on the randomness of the position chain pos_chain(ls i -L min ), for the original metabolic source pseudo-random string, the output pseudo-random string tmp_str(j), j = 0, 1, 2,..., ls i - 1, perform a pseudo-random bit rearrangement different from (4.1); (4.2.2) When performing the pseudo-random bit rearrangement in (4.2.1), perform bit-by-bit interchange; (4.2.3) Sugar addition: Trigger the replacement of the metabolic source pseudo-random string with a bit string of all '0's or all '1's according to the state that appears intermittently in the calculation parameter; Examples of the state that appears intermittently in the calculation parameter: (a), the position element at a specific position in the position chain is equal to 0 or ls i , or (b), the value of a certain determined byte in the dynamic drive vector i is equal to 0 or ls i , or (c), the combination of (a) or (b) above holds without contradiction; (5) With the support of the chaotic computing structure, the bit extraction logic, bit metabolism logic, and other listed related logics are used in combination to construct a regeneration key bit segment sequence of 'pseudo-randomly misaligned extraction of unmetabolized construction source bits or re-extraction of metabolized construction source bits'.

6. The sequence encryption method for reconstructing keys according to claim 1, characterized in that: Use the chaotic computing structure to eliminate the periodic law that may appear in the constructed regeneration key bit segment sequence; (1) Utilize the pseudo-random variation of the bit segment length ls caused by the chaotic computing structure i to disrupt the regularity of the changes of the metabolized bits; (2) Utilize the pseudo-random variation of the bit segment length ls caused by the chaotic computing structure i to disrupt the regularity of the value variation of the repeatedly extracted bits.

7. The sequence encryption method for reconstructing keys according to claim 1, characterized in that: Based on the chaotic computing structure, realize the misaligned winding between different regeneration key bit segment sequences and embed the pseudo-random bit winding to realize the misaligned superposition encryption of the misaligned winding between the front and back bit segments; (1) Based on the chaotic computing structure, perform same-scale segmentation on the plaintext bit segment, regeneration key bit segment, and ciphertext bit segment; (1.1) Using the bit segment length limit values L min and L max to determine λ, where (1 / 2)L min ≤ λ < (1 / 2)L max , and using this as the bit segment segmentation scale sd; (1.2) Use sd as the misaligned segment difference to determine the segment difference between two groups of regeneration key bit segment sequences with the same number s, s≥1; (2) Construct two groups of regeneration key bit segment sequences that belong to different segmentations and have differences; (2.1) Establish two groups of regenerated key bit segment sequences; the first regenerated key bit segment sequence group bsk1 i,q , the second regenerated key bit segment sequence group bsk2 i,q , q = 1, 2,..., si = 0, 1, 2,... where q is the subscript of each regenerated key bit segment sequence belonging to each group, s is the number of regenerated key bit segment sequences in each group, and i is the round number; (2.2) The regeneration key segments in each group of regeneration key bit sequences follow the scale sd for segmentation: k1f i,q , with a length of sd; k1l i,q , with a length of ls i - sd; k2f i，q , with a length of ls i - sd; k2l i，q , with a length of sd; The plaintext segment is also segmented at the same scale: Mf i , with a length of sd; Ml i , with a length of ls i - sd; (2.3) Determine different bit extraction logics, bit metabolism logics, or different construction sources and control sources for each regeneration key bit segment sequence; (3) Determine the pseudo-random bit rearrangement logic implemented by 2s - 1 position chains pos_chain(ls i -L min , j), where j = 0, 1,..., ls - 1 (4) Misaligned superposition encryption based on different regeneration key bit segment sequences with pseudo-random bit winding embedded in the same-scale segmentation: (4.1) Use s buffers with a length of sd to store the second half key bit segments k2l of each group of secondary regeneration key bit segment sequences, where q = 1, 2,..., s; i,q , q = 1, 2,..., s; (4.2) Except for the first round, the other rounds are encrypted with misaligned segments in the following order: k1f i,q ||k1l i,q ,q = 0; i,r，r＝r+1； k2l i-1,q ||k2f i,q ; q = q + 1; i,r；r＝r+1； …… k1f i,s ||k1l i,s ; i, 2s - 1; k2l i-1,s ||k2f i,s ; (5) Misaligned decryption based on different regeneration key bit segment sequences with pseudo-random bit winding embedded in the same-scale segmentation: (5.1) Established before decryption begins: (1) A position chain stack stack_chain of length L max for storing the position chain; (2) A half-segment stack stack_k2f of length L max - sd for storing the first half-segments of s secondary regeneration key segments; (3) A half-segment stack stack_k2l of length sd for storing the second half-segments of s secondary regeneration key segments for the next round of misaligned segment splicing; (4) A misaligned half-segment stack s_stack_k2l of length sd for copying out the half-key segments k2l stored in the half-segment stack stack_k2l in the previous round i-1,q to splice the misaligned secondary regeneration key segments k2l i-1,q || k2f i,q ; (5) A full-segment stack stack_bsk1 of length L max for storing the first regeneration key segments used in the current round; (5.2) Except for the first round, at the beginning of each round of decryption, copy the second half-bit segment k2l of all the secondary regeneration key bit segments pushed into stack_k2l in the previous round, where q = 0, 1,..., s - 1, into s_stack_k2l, and clear stack_k2l; i-1,q , q = 0, 1,..., s - 1 are copied into s_stack_k2l, and stack_k2l is cleared; (5.3) Except for the first round, s times of computational reconstruction or extraction are performed in the order of encryption processing in each round: (1) Reconstruct the regeneration key bit segment bsk1 i,q and push it into the entire stack stack_bsk1, and perform the position chain pos_chain(ls i -L min ) metabolism; (2) Push the position chain pos_chain(ls i -L min ) into the position chain stack stack_chain and perform the position chain pos_chain(ls i -L min ) metabolism; (3) Reconstruct the regeneration key bit segment bsk2 i,q , q = 0, 1,..., s - 1 and push it into the half stacks stack_k2f, stack_k2l and perform the position chain pos_chain(ls i -L min ) metabolism; (4) Except for the s-th time, push the position chain pos_chain(ls i -L min ) into the position chain stack stack_chain and perform the position chain pos_chain(ls i -L min ) metabolism; (5.4) Except for the first round, the other rounds are decrypted with misaligned segments in the reverse order of (5.3): k2l i-1,q ||k2f i，q ,q = s; i, r, r = 2s - 2; r = r - 1; k1f i，q ||k1l i，q ,q = s; q = q - 1; …… i,r，r＝r-1； k2l i-1，0 ||k2f i，0 ; i，0； k1f i，0 ||k1l i，0 ; (5.5) In each decryption round and each time, the half-bit segment length uses sd or ls i - sd, omitting L max _ls i of the redundant part.

8. The sequence encryption method for reconstructing a key according to claim 1, wherein: Use the plaintext end symbol EOP to resolve the misalignment between the plaintext end bit and the encryption end bit caused by the chaotic encryption process; use the plaintext end symbol EOP as the verification code for the correctness of the decryption calculation; (1) At the beginning of encryption / decryption, generate the end-of-plaintext symbol EOP and an appended pseudo-random string ms of length L which is the maximum value limited by the bit segment length according to the initial dynamic drive vector vector0, and append the two to the end of the plaintext; max additn ​ (2) During the encryption process, stop the calculation when the calculated bit segment length ls i is less than the length of the unencrypted plaintext; (3) After decryption is completed, use the plaintext end symbol EOP to determine the position of the plaintext end and verify the correctness of the plaintext generated by decryption.

Images