CN102221989A - Microprocessor and related operation method, and encryption and decryption method - Google Patents

Abstract

The invention relates to a microprocessor and a related operation method, and an encryption and decryption method. The microprocessor operates with an extraction unit: fetching a block of instruction data from an instruction cache of a microprocessor; (b) performing Boolean operation on the block by a data entity to generate plain character instruction data; and (c) providing the plain text instruction data to an instruction decoding unit. In a first case, the block includes encrypted command data and the data entity is the decryption key. In a second case, the block includes non-encrypted instruction data and the data entity is a binary zero value of a plurality of bits. The time required to perform the above-described contents , (b), and (c) is the same in the first condition and the second condition regardless of whether the instruction data of the block is encrypted or unencrypted.

Description

Microprocessor and related operation method, and encryption and decryption method

technical field

The present invention relates to the field of microprocessor (microprocessor), in particular to a method for increasing the security of programs executed by the microprocessor.

Background technique

Many software programs are generally vulnerable to attacks that compromise the security of computer systems. For example, a hacker can implant improper program code by attacking a buffer overflow vulnerability of a running program, and transfer control rights to the improper program code. In this way, the implanted program code will dominate the attacked program. A solution to prevent software programs from being attacked is instruction set randomization. Roughly explained, the instruction set randomization technology first encrypts the program into some form, and then decrypts the program in the processor after the processor fetches the program from the memory. In this way, it is difficult for a hacker to implant malicious instructions, because the implanted instructions must be properly encrypted (for example, using the same encryption key or algorithm as the attacked program) to be correctly executed. For example, see the document "Counter Code-Injection Attacks with Instruction-Set Randomization, by Gaurav S.Kc, Angelos D. Keromytis, and Vassilis Prevelakis, CCS'03, October 27-30, 2003, Washington, DC, USA, ACM 1 -58113-738-9/03/0010", which describes an improved version of the Bochs-x86Pentium emulator (emulator). The disadvantages of related techniques have been widely discussed. See, for example, the data "Where's the FEEB? The Effectiveness of Instruction Set Randomization, by Ana Nora Sovarel, David Evans, and Nathanael Paul, http://www.cs.virginia.edu/feeb ."

Contents of the invention

One embodiment of the invention discloses a microprocessor. The microprocessor includes an instruction cache memory, an instruction decoding unit, and a fetching unit. The fetch unit is used for: (a) fetching instruction data of a block from the instruction cache memory; (b) performing a Boolean XOR operation on the block with a data entity to generate plain text instruction data; and ( c) Providing the above-mentioned plain text instruction data to the instruction decoding unit. In a first case, the block includes encrypted instruction data, and the data entity is a decryption key. In a second condition, the block includes non-encrypted command data, and the data entity is a plurality of bits of binary zero value. Regardless of whether the command data of the block is encrypted or not, the time required to implement the above content (a), (b) and (c) is the same under the first situation and the second situation.

Another embodiment of the present invention discloses a method for operating a microprocessor having an instruction cache. The method includes: (a) fetching a block of instruction data from the instruction cache; (b) performing a Boolean XOR operation on the block with a data entity to generate plain text instruction data; and (c) The plain text instruction data is supplied to an instruction decoding unit. In a first case, the block includes encrypted instruction data, and the data entity is a decryption key. In a second condition, the block includes non-encrypted command data, and the data entity is a plurality of bits of binary zero value. Regardless of whether the command data of the block is encrypted or not, the time required to implement the above content (a), (b) and (c) is the same under the first situation and the second situation.

One embodiment of the present invention provides a microprocessor. The microprocessor includes an instruction cache and a fetch unit. The fetching unit fetches a sequence of encrypted instructions of a plurality of blocks of an encryption program from a sequence of a plurality of fetch addresses in the instruction cache. When extracting each block of the sequence, the extracting unit further uses a plurality of key values and part of the extracted address of the extracted block as a function to generate a decryption key. For the extracted blocks of the sequence, the extracting unit also uses the corresponding decryption key to decrypt the encrypted instructions therein. The microprocessor also includes a key switching instruction, which instructs the microprocessor to update the key values in the fetching unit when the fetching unit fetches the sequence of blocks from the instruction cache.

Another embodiment of the present invention discloses a method of operating a microprocessor having an instruction cache. The method includes fetching a plurality of first encrypted instructions of a program from the instruction cache, and decrypting them into a plurality of first non-encrypted instructions with a first decryption key. The method also includes replacing the first decryption key with a second decryption key in response to a key switch command among the first non-encrypted commands. The method also includes fetching a plurality of second encrypted instructions of the program from the instruction cache, and decrypting them with the second decryption key into a plurality of second non-encrypted instructions.

Another embodiment of the present invention discloses a method for operating a microprocessor. The method includes fetching an encrypted program, a sequence of encrypted instructions of a plurality of blocks, from an instruction cache memory, a sequence of fetched addresses. The method also includes generating a decryption key by using a plurality of key values and part of the extraction address of the extracted block as a function when extracting each block of the sequence. The method also includes, for each block in the sequence, decrypting the encrypted instruction therein using the corresponding decryption key. The method also includes executing a key switching instruction when extracting the sequence of the plurality of blocks. Executing the key switching instruction includes updating the key values used to generate the decryption key.

An embodiment of the present invention discloses a microprocessor. The microprocessor includes an extraction unit for extracting and decrypting a branch and switch key instruction using the first decryption key data. The microprocessor also includes microcode. When the direction of the branch and switch key instruction is not adopted, the microcode instructs the extracting unit to use the first decryption key data to extract and decrypt the continuation instruction after the branch and switch key instruction. The microcode also causes the extraction unit to extract and decrypt the branch and switch key instruction using second decryption key data different from the above-mentioned first decryption key data under the condition that the branch and switch key instruction is adopted. A target instruction.

Another embodiment of the present invention discloses a method for processing an encryption program with a microprocessor. The method includes extracting and decrypting a branch and switch key instruction using the first decryption key data. The method further includes, under the condition that the direction of the branch and switch key instruction is not taken, extracting and decrypting a continuation instruction after the branch and switch key instruction with the above-mentioned first decryption key data. The method also includes extracting and decrypting a part of the branch and switch key instruction with second decryption key data different from the above-mentioned first decryption key data under the condition that the direction of the branch and switch key instruction is taken. target instruction.

Another embodiment of the present invention also discloses a method for encrypting a program for later execution by a microprocessor for decrypting and executing the encrypted program. The method includes receiving an object file of an unencrypted program, including conventional branch instructions, indicating a target address that can be determined before the microprocessor executes the program. The method also includes analyzing the program to obtain block information. The above-mentioned block information divides the program into a sequence of multiple blocks. Each block includes a sequence of multiple instructions. The above block information also includes encryption key data related to each block. The encryption key data corresponding to each block is different. The method also includes replacing the target address and itself located in a different block in the traditional branch instructions with a branch and switch key instruction respectively. The method also includes encrypting the program based on the above block information.

Another embodiment of the present invention also discloses a method for encrypting a program for later execution by a microprocessor for decrypting and executing the encrypted program. The method includes receiving an object file of an unencrypted program, including conventional branch instructions, indicating target addresses that can only be determined when the microprocessor executes the program. The method also includes analyzing the program to obtain block information. The above-mentioned block information divides the program into a sequence of multiple blocks. Each block includes a sequence of multiple instructions. The above block information also includes encryption key data related to each block. The encryption key data corresponding to each block is different. The method further includes replacing each of the conventional branch instructions with a branch and switch key instruction. The method also includes encrypting the program based on the block information.

One embodiment of the invention discloses a microprocessor. The microprocessor includes an architectural register including a bit. The microprocessor is responsible for setting this bit. The microprocessor also includes an extraction unit. The fetching unit fetches encrypted instructions from an instruction cache memory, and decrypts the encrypted instructions before executing the encrypted instructions, in response to the microprocessor's operation of setting the bit. If an interrupt is received, the microprocessor stores the value of the bit to a stack memory and then clears the bit. After the microprocessor clears the bit, the fetch instruction is to fetch the non-encrypted instruction from the instruction cache, and execute it without decrypting the above-mentioned non-encrypted instruction. The microprocessor also uses the previously stored value from the stack memory to restore the bit of the architectural register in response to a return from an interrupt instruction. If it is determined that the repaired value of the bit is set, the extraction unit re-extracts and decrypts the encrypted instruction.

Another embodiment of the present invention discloses a method for operating a microprocessor having an instruction cache and an architectural register. The method includes setting a bit in the architectural register, and then fetching an encrypted instruction from the instruction cache, and decrypting the encrypted instruction before executing the encrypted instruction. In response to an interrupt, the method also includes storing the value of the bit of the architectural register, and subsequently clearing the bit. After clearing the bit, the method also includes fetching the non-encrypted instruction from the instruction cache and executing the non-encrypted instruction without decryption. The method also includes restoring the bit of the architectural register with a previously stored value in response to a return from the interrupt instruction. If it is determined that the repaired value of the bit is a set state, the method further includes re-extracting and decrypting and executing the encrypted instruction.

Another embodiment of the present invention discloses a microprocessor. The microprocessor includes an architectural register including one bit and a fetch unit. The microprocessor stores the value of the bit in response to a request to interrupt an executing program. This bit indicates whether the program in execution is encrypted or not encrypted. The microprocessor restores the bit with the previously stored value and refetches the interrupted program as the running program in response to the return from the interrupt instruction. If the repaired value of the bit is set, the microprocessor first restores the decryption key value before re-fetching the interrupted program, so as to use the repaired decryption key value to decrypt the fetched instruction. If the repaired value of the bit is cleared, the microprocessor does not restore the value of the decryption key, and does not decrypt the fetched instruction.

Another embodiment of the present invention discloses a method for operating a microprocessor. The method includes storing a value of one bit of the microprocessor in response to a request to interrupt an executing program. This bit indicates whether the program in execution is encrypted or not encrypted. In response to returning from the interrupt instruction, the method also includes resetting the bit with a previously stored value, and refetching the interrupted program as the running program. If the restored value of the bit is set, the method further includes restoring the decryption key value before re-extracting the interrupt program, and decrypting the fetched instruction with the restored decryption key value. If the repaired value of the bit is cleared, this method will not restore the decryption key, and will not decrypt the extracted instruction.

An embodiment of the present invention discloses a microprocessor. The microprocessor includes a storage element having a plurality of locations each storing decryption key data of an encryption program. The microprocessor also includes a control register, which uses a field to mark one of the above-mentioned multiple locations of the storage element that is related to the encryption program being executed. In response to a return from the interrupt instruction, the microprocessor restores the control register from memory with the previously stored value of the field. The microprocessor also includes an extracting unit, which is used to extract the encryption instruction of the encryption program being executed, and decrypt the decryption key data stored in the location marked by the storage element with the repaired value of the field.

Another embodiment of the present invention discloses a method for operating a microprocessor having a control register and a storage element, wherein a plurality of locations in the storage element respectively store decryption key data of an encryption program. The method includes using a previously stored value of the field from the memory to restore a field in the control register in response to an operation returned from an interrupt instruction, wherein the value of the field indicates that the storage element is in the plurality of locations and is executing encryption procedure. The method also includes extracting encrypted instructions of the encrypted program in execution. The method further includes decrypting the extracted encrypted instruction with the decryption key data stored in the location indicated by the storage element with the repaired value of the field.

An embodiment of the present invention discloses a microprocessor. The microprocessor includes a Branch Target Address Cache (BTAC) to record history information of previously executed branch and switch key instructions. The above historical information includes the recorded target addresses and identifiers of branch and switch key instructions. The above-mentioned identifiers indicate a plurality of key values related to the branch and switch key instruction. The microprocessor also includes a fetch unit coupled to the branch target address cache memory. The fetch unit, when fetching previously executed branch and switch key instructions, receives predictions made by the branch target address cache and receives information about the fetched branch and switch key instructions from the branch target address cache The above target address and identifier. The extraction unit also extracts encrypted instruction data according to the received target address, and decrypts the extracted encrypted instruction data according to the plurality of key values indicated by the received identifier, in response to the received prediction.

Another embodiment of the present invention discloses a method for operating a microprocessor. The method includes recording history information of previously executed branch and switch key instructions with a branch target address cache (BTAC). The above historical information includes the recorded target addresses and identifiers of branch and switch key instructions. The above-mentioned identifiers indicate a plurality of key values related to the branch and switch key instruction. The method further receives predictions made by the branch target address cache when previously executed branch and switch key instructions are fetched, and receives information about the fetched branch and switch key instructions from the branch target address cache The above target address and identifier. The method further extracts encrypted command data according to the received target address, and decrypts the extracted encrypted command data according to the plurality of key values indicated by the received identifier, in response to the received prediction.

Description of drawings

Figure 1 is a block diagram illustrating a microprocessor implemented in accordance with the techniques of the present invention;

Fig. 2 is a block diagram for explaining the extracting unit of Fig. 1 in detail;

FIG. 3 is a flow chart illustrating the operation of the extraction unit of FIG. 2 in accordance with the techniques of the present invention;

Fig. 4 is a block diagram illustrating the fields of the flag register of Fig. 1 according to the technology of the present invention;

Figure 5 is a block diagram illustrating the format of a key load command according to the techniques of the present invention;

FIG. 6 is a block diagram illustrating the format of a key switching command according to the technology of the present invention;

FIG. 7 is a flow chart illustrating the operation of the microprocessor of FIG. 1 in which the key switching instruction of FIG. 6 is executed, according to the technology of the present invention;

FIG. 8 is a block diagram illustrating the memory usage of an encryption program including a plurality of key switching instructions disclosed in FIG. 6 according to the technology of the present invention;

Figure 9 is a block diagram illustrating the format of a branch and switch key instruction in accordance with the techniques of the present invention;

Figure 10 is a flowchart illustrating the operation of the microprocessor of Figure 1 in which the branch and switch key instructions of Figure 9 are executed, in accordance with the teachings of the present invention;

Figure 11 is a flow chart illustrating the operation of a post-processor, implemented by software tools, for post-processing a program and encrypting it for execution by the microprocessor of Figure 1, according to the techniques of the present invention;

FIG. 12 is a block diagram illustrating the format of branch and switch key instructions in another embodiment of the present invention;

Figure 13 is a block diagram illustrating a block address range table according to the technology of the present invention;

Figure 14 is a flowchart illustrating the operation of the microprocessor of Figure 1 in which the branch and switch key instructions of Figure 12 are executed, in accordance with the teachings of the present invention;

15 is a block diagram illustrating the format of branch and switch key instructions in another embodiment of the present invention;

Fig. 16 is a block diagram illustrating a block address range table according to the technology of the present invention;

Figure 17 is a flowchart illustrating the operation of the microprocessor of Figure 1 in which the branch and switch key instructions of Figure 15 are executed, in accordance with the teachings of the present invention;

Fig. 18 is a flow chart illustrating another embodiment of the present invention technology, wherein the operation of a post-processor is described for post-processing a program and encrypting it, which is executed by the microprocessor of Fig. 1;

FIG. 19 is a flow chart illustrating the operation of the microprocessor of FIG. 1 for handling a task switch between an encrypted program and a plain text program according to the technology of the present invention;

Figure 20 illustrates a flowchart illustrating the operation of system software executed by the microprocessor of Figure 1 in accordance with the teachings of the present invention;

FIG. 21 illustrates a block diagram illustrating the fields of the flag register in FIG. 1 according to another embodiment of the present invention;

Fig. 22 is a flow chart illustrating the operation of the microprocessor of Fig. 1 using the flag register of Fig. 21 according to the technology of the present invention, for coping with a task switching between a plurality of encryption programs;

Fig. 23 is a flowchart illustrating the operation of the microprocessor of Fig. 1 using the flag register of Fig. 21, according to the technology of the present invention, for coping with a task switch between a plurality of encryption programs;

Fig. 24 is a block diagram illustrating a single register in the key register file of Fig. 1 according to another embodiment of the present invention;

Fig. 25 is a flow chart illustrating the operation of the microprocessor of Fig. 1 using the flag register of Fig. 21 and the key register file of Fig. 24 to cope with a task switch and switch between multiple encryption programs according to another embodiment of the present invention between;

Fig. 26 is a flow chart illustrating the operation of the microprocessor of Fig. 1 using the flag register of Fig. 21 and the key register file of Fig. 24 to cope with a task switch between multiple encryption programs according to another embodiment of the present invention between;

FIG. 27 is a block diagram illustrating other embodiments of portions of the microprocessor 100 of FIG. 1;

28 is a block diagram illustrating in detail the Branch Target Address Cache (BTAC) of FIG. 27 in accordance with the teachings of the present invention;

FIG. 29 is a block diagram illustrating in detail the contents of each unit of the BTAC in FIG. 28 according to the technology of the present invention;

Figure 30 is a flow chart illustrating the operation of the microprocessor of Figure 27 using the BTAC of Figure 28 in accordance with the techniques of the present invention;

Figure 31 is a flowchart illustrating the operation of the microprocessor of Figure 27 using the BTAC of Figure 28 in accordance with the teachings of the present invention; and

Figure 32 is a flowchart illustrating the operation of the microprocessor of Figure 27 for a branch and switch key instruction, in accordance with the teachings of the present invention; and

Description of reference symbols

100～microprocessor; 102～instruction cache memory;

104～extraction unit; 106～command data (can be encrypted);

108～decoding unit; 112～execution unit;

114～exit unit; 118～general register;

122～secure storage area; 124～key register file;

128～flag register; 132～microcode unit;

134～extraction address; 142～master key register;

144～control register; 148～E bit;

152～key expander; 154～multiplexer;

156～different logic; 162～plain text instruction data;

164～extract instruction generator; 172～two sets of keys;

174～decryption key; 176～multi-digit binary zero value;

178～the output of multiplexer 154;

212～multiplexer A; 214～multiplexer B;

216～rotator; 218～addition/subtractor;

234～the first key; 236～the second key;

238～rotator output; 302-316～step block;

402～E bit field;

408～multiple standard x86 flags;

500～Key loading instruction; 502～Operation code;

504～key register file target address;

506～source address of safe storage area;

600～Key switching instruction; 602～Operation code;

604～key register document index;

702-708～block steps; 800～memory usage;

900～branch and switch key instructions;

902～operation code; 904～key register document index;

906～branch information; 1002-1018～step block;

1102-1106～step block; 1200～branch and switch key instruction;

1202～operation code; 1300～block address range table:

1302～address range; 1304～key register document index;

1402-1418～step block; 1500～branch and switch key instructions;

1502～operation code; 1600～block address range table:

1604～safe storage area address;

1714～step block; 1802-1806～step block;

1902-1944 ~ step block; 2002-2008 ~ step block;

2104～index; 2202-2216～step block;

2302-2316～step square; 2402～elimination bit;

2506～step block; 2607, 2609～step block;

2702～branch target address cache memory (BTAC);

2706～target address; 2708～use/not use indicators;

2712～key switching logic; 2714～type index;

2716～key register document index;

2802～BTAC array; 2808～BTAC unit;

2902～effective bit; 2904～mark field;

2906～target address; 2908～use/not use field;

2912～key register document index;

2914～type field; 3002-3004～step block;

3102-3116～step blocks; 3208-3222～step blocks; and

ZEROS - multi-digit binary zero value.

Detailed ways

Referring to FIG. 1, a block diagram illustrates a microprocessor 100 implemented in accordance with the techniques of the present invention. The microprocessor 100 includes a pipeline (pipeline), which includes an instruction cache (instruction cache) 102, a fetch unit (fetch unit) 104, a decoding unit (decodeunit) 108, an execution unit (execution unit) 112, and a retire unit 114 . The microprocessor 100 also includes a microcode unit 132 for providing microcode instructions to the execution unit 112 . The microprocessor 100 also includes general purpose registers 118 and flag registers (EFLAGS register) 128 for providing instruction operands to the execution unit 112 . Furthermore, the command execution result is updated in the general register 118 and the flag register 128 through the export unit 114 . In one implementation manner, the flag register 128 is realized by modifying the traditional x86 flag register, and the detailed implementation manner will be described later.

The fetch unit 104 fetches instruction data (instruction data) 106 from the instruction cache 102 . The extraction unit 104 operates in two modes: one is a decryption mode, and the other is a plain text mode. An E bit (E bit) 148 of a control register (control register) 144 in the extraction unit 104 determines whether the extraction unit 104 operates in a decryption mode (setting the E bit) or operating in a plain text mode (clearing the E bit). In the plain text mode, the fetching unit 104 regards the command data 106 fetched from the command cache 102 as unencrypted or plain text command data, and therefore does not decrypt the command data 106 . However, in the decryption mode, the fetching unit 104 regards the command data 106 extracted from the command cache memory 102 as encrypted command data, therefore, a master key register (master key register) 142 of the fetching unit 104 needs to be used The stored decryption keys (decryption keys) decrypt it into plain text instruction data. The detailed technical content will be discussed with reference to FIG. 2 and FIG. 3 .

The fetch unit 104 also includes a fetch address generator 164 for generating a fetch address 134 for fetching the command data 106 from the command cache 102 . The extraction address 134 is also supplied to a key expander 152 of the extraction unit 104 . The key expander 152 selects two sets of keys 172 from the temporary key storage 142 and performs operations on them to generate a decryption key 174 as a first input of the multiplexer 154 . The second input of the multiplexer 154 is a multi-bit binary zeros 176 . The E bit 148 controls the multiplexer 154 . If the E bit 148 is set, the multiplexer 154 selects the encryption key 174 for output. If the E bit 148 is cleared, the multiplexer 154 selects the output multi-bit binary zero value 176 . The output 178 of the multiplexer 154 will be supplied to the exclusive logic 156 as its first input. The exclusive logic 156 is responsible for performing a Boolean exclusive-OR (Boolean exclusive-OR, XOR) operation on the extracted command data 106 and the multiplexer output 178 to generate the plain text command data 162 . The encrypted instruction data 106 is pre-encrypted with the original plain text instruction data using exclusive logic with an encryption key, wherein the value of the encryption key is the same as that of the decryption key 174 . The detailed implementation of the extracting unit 104 will be described later in conjunction with FIG. 2 and FIG. 3 .

The plain text instruction data 162 will be supplied to the decoding unit 108 . The decoding unit 108 is responsible for decoding the stream of plain text instruction data 162 and dividing it into a plurality of X86 instructions for execution by the execution unit 112 . In one embodiment, the decoding unit 108 includes buffers or queues to buffer the stored stream of plain text instruction data 162 before or during decoding. In one embodiment, the decoding unit 108 includes an instruction translator for translating X86 instructions into microinstructions or micro-ops, which are executed by the execution unit 112 . When the decoding unit 108 outputs instructions, it will output a bit value for each instruction, and the bit value is accompanied by the instruction along the pipeline structure to indicate whether the instruction is an encrypted instruction. The bit value will control the execution unit 112 and the fetch unit 114 to make decisions and take actions according to whether the instruction is an encrypted instruction or a plain text instruction when fetched from the instruction cache 102 . In one embodiment, plain text instructions are not allowed to perform specific operations designed for the instruction decryption mode.

In one embodiment, the microprocessor 100 is an x86 architecture processor, however, the microprocessor 100 can also be implemented by a processor of other architectures. A processor is considered an x86 architecture processor if it can correctly execute most applications designed for x86 processors. If the expected result can be obtained after the application program is executed, it can be judged that the application program is executed correctly. In particular, the microprocessor 100 executes instructions of the x86 instruction set, and has an x86 user-visible register set (x86 user-visible register set).

In one embodiment, the microprocessor 100 is designed to provide a comprehensive security architecture (called a secure execution mode (SEM)) for executing programs therein. According to one embodiment, the execution of the SEM program can be triggered by several processor events and is not blocked from normal (non-SEM) operations. The following examples illustrate the functions implemented by programs that are limited to execution under the SEM, including critical security tasks such as: credential verification and data encryption, system software activity monitoring, system software integrity verification, resource usage tracking, new software The installation control of ...etc. Please refer to the U.S. patent application filed by our company on October 31, 2008 for the implementation of the SEM, case number 12/263,131, (U.S. Patent Publication No. 2009-0292893, published on November 26, 2009); The priority claim of the case can be traced back to the US Patent Provisional Application (Case No. 61/055,980) dated May 24, 2008; the relevant technical parts of this application can refer to the content of the above case. In one embodiment, the secure non-volatile memory (not shown) used to store the SEM data - such as a flash memory - can be used to store the decryption key and is accessed via an isolated serial The bus (private serial bus) is coupled to the microprocessor 100, and all data therein are AES-encrypted and signed-verified. In one embodiment, microprocessor 100 includes a small amount of single write-once non-volatile memory (non-volatile write-once memory, not shown in the figure) for storing decryption keys; one of For the implementation manner, reference may be made to a fuse type non-volatile memory disclosed in US Pat. No. 7,663,957; the contents of the above cases may be referred to and applied to the present invention. One of the advantages of the instruction decryption feature disclosed by the present invention is that it expands the scope of application of the Secure Execution Mode (SEM), so that the secure program (secure program) can be stored in the memory outside the microprocessor 100, and there is no need to limit the complete storage in the memory. Inside the microprocessor 100 . Thus, security programs can take advantage of the full space and functionality provided by the memory hierarchy. In one embodiment, some or all of the structural exceptions/interrupts (architectural exceptions/interrupts, for example, page faults, debug breakpoints, debug breakpoints)... etc. are disabled in SEM mode. )of. In one embodiment, some or all of the structural exceptions/interrupts are disabled in decrypted mode (ie, E bit 148 is set).

The microprocessor 100 also includes a key register file 124 . The key register file 124 includes a plurality of registers, and the key stored therein can be loaded into the master key register 142 of the extraction unit 104 by a key switching instruction (switch key instruction, discussed later) to decrypt the extracted encrypted instruction Data 106.

The microprocessor 100 also includes a secure memory area (secure memory area, abbreviated as SMA) 122 for storing the decryption key, which is to be loaded by the key loading instruction (load key instruction) 500 shown in FIG. The key register file 124 is then loaded. In one embodiment, the secure storage area 122 is restricted to be accessed by the SEM program. That is to say, the secure storage area 122 cannot be accessed by programs executed in the normal execution mode (non-SEM). Furthermore, the secure memory area 122 is also inaccessible via the processor bus and is not part of the cache memory hierarchy of the microprocessor 100 . Therefore, for example, a cache flush operation does not cause the contents of the secure storage area 122 to be written into memory. Regarding the reading and writing of the secure storage area 122 , specific instructions are designed in the instruction set architecture of the microprocessor 100 . One embodiment is to design an isolated random access memory (private RAM) in the safe storage area 122. For related technical content, reference can be made to U.S. patent application 12/034,503 filed on February 20, 2008 (this case was filed in 2008 It was published on October 16, and the publication number is 2008/0256336); it can be applied to the present invention with reference to the content of the above case.

Initially, an operating system or other privileged program download key is initially set in the secure storage area 122 , the key register file 124 , and the master key register 142 . The microprocessor 100 first decrypts an encrypted program with the initial setting of the key. In addition, the encryption program itself can then write new keys to the secure storage area 122, and from the secure storage area 122, load the key into the key register file 124 (by the key load command), and from the key register Document 124 loads the key into master key register 142 (via a key switch command). The advantage of the operation is that the disclosed key switching instruction enables on-the-fly switching of the encryption program during execution, which will be described in detail below. The new key can consist of the instant data of the encryption program instruction itself. In one embodiment, a field in the header of the program file indicates whether the program instructions are in encrypted form.

The technique described in Figure 1 has several advantages. First, the plain text command data decrypted from the encrypted command data 106 cannot be obtained outside the microprocessor 100 .

Second, the extraction unit 104 takes the same time to extract encrypted instruction data as it takes to extract plain text instruction data. This feature is related to safety or not. Conversely, if there is a time difference, hackers can use this to break the encryption technology.

Third, compared with the traditional design, the instruction decryption technique disclosed in the present invention does not increase the number of clocks consumed by the fetch unit 104 additionally. As discussed below, key expander 152 increases the effective length of the decryption key used to decrypt an encrypted program in such a way that extraction of encrypted program data does not take longer than extraction of plain text program data time. In particular, because the operation of the key expander 152 is time-limited to be completed within the instruction data 106 obtained by looking up the instruction cache memory 102 with the fetch address 134, the key expander 152 does not increase the time of the general fetch procedure. In addition, because the multiplexer 154 and the key expander 152 are both completed within the time limit for obtaining the command data 106 by looking up the command cache memory 102 with the fetch address 134, the time of the general fetch procedure will not be increased. The exclusive logic operation 156 is the only logical operation added to the general extraction path. Fortunately, the propagation delay of the exclusive logic operation 156 is quite small and does not increase the duty cycle. Therefore, the instruction decryption technique disclosed in the present invention will not increase the burden on the number of clocks of the fetch unit 104 . In addition, compared to the complex decryption mechanism, such as S-boxes, applied to the decryption data 106 by the conventional technology, the conventional technology will increase the duty cycle required to fetch and decode the command data 106 and/or consume number of clocks.

Next, referring to FIG. 2 , a block diagram illustrates the extraction unit 104 of FIG. 1 in detail. In particular, the key expander 152 of FIG. 1 is also shown in detail. The advantages of using exclusive logic to decrypt the above-mentioned encrypted instruction data 106 have been discussed previously. However, fast and small XOR has its disadvantages: XOR is a weak encryption method if the encryption/decryption key is reused. However, if the effective length of the key is equal to the length of the program to be encrypted/decrypted, heterological encryption will be a very strong encryption technique. The microprocessor 100 features the ability to increase the effective length of the decryption key to reduce the need for key reuse. First, the value (file) stored in the master key register 142 is medium to large in size: in one embodiment, its size is equivalent to the extraction amount or block size of the instruction data 106 fetched from the instruction cache memory 102 , which is 128 bits (16 bytes). Second, the encryption extender 152 is used to increase the effective length of the decryption key, for example, to 2084 bytes disclosed in an embodiment, which will be described in detail later. Third, the encryption program can change the value in the master key register 142 during operation through the key switching command (or its variant), which will be described in detail in the following paragraphs.

In the embodiment shown in Figure 2, five master key registers 142, numbered 0-4, are used. However, in other embodiments, the decryption key length may be increased by a smaller or larger number of master key registers 142 . For example, one embodiment employs 12 master key registers 142 . The key expander 152 includes a first multiplexer A 212 and a second multiplexer B 214 for receiving the key supplied by the master key register 142. Portions of address 134 are extracted for use in controlling multiplexers 212/214. In the embodiment shown in FIG. 2, the multiplexer B 214 is a three-turn-one multiplexer, and the multiplexer A 212 is a four-turn-one multiplexer. Table 1 shows how the multiplexers 212/214 select these master key registers 142 (identified by the numbers above) according to their respective select inputs. Table 2 shows how the above select inputs are generated, and the master key register 142 combination based on bits [10:8] of the fetch address 134 .

Table 1

Form 2

The output 236 of the multiplexer B 214 is supplied to the adder/subtractor 218. The output 234 of the multiplexer A 212 is supplied to a rotator 216. The rotator 216 receives bits [7:4] of the fetch address 134 and rotates the multiplexer output 234 accordingly to determine the number of bytes to rotate. In one embodiment, bits [7:4] of the fetch address 134 are incremented by the number of bytes supplied to the rotator 216 to control the rotation, as shown in Table 3 above. The output 238 of the rotator 216 is supplied to the adder/subtractor 218 . Adder/subtractor 218 receives bit[7] of fetch address 134 . If the bit [7] is clear, the adder/subtractor 218 subtracts the output 238 of the rotator 216 from the output 236 of the multiplexer B 214. If bit [7] is set, the adder/subtractor 218 adds the output 238 of the rotator 216 to the output 236 of the multiplexer B 214. The output of the adder/subtractor 218 , the decryption key 174 shown in FIG. 1 , is supplied to the multiplexer 154 . The related technology will be described in detail below with the flowchart of FIG. 3 .

Next, referring to FIG. 3 , a flowchart illustrates the operation of the extraction unit 104 in FIG. 2 based on the technology of the present invention. Flow begins at block 302 .

At block 302 , the fetch unit 104 reads the instruction cache 102 with the fetch address 134 to start fetching a 16-byte block of instruction data 106 . The command data 106 can be encrypted or plain text, depending on whether the command data 106 is part of an encrypted program or a plain text program, which is indicated by the E bit 148 . The flow then goes to block 304 .

Referring to block 304, according to the higher bits of the extracted address 134, the multiplexer A 212 and the multiplexer B 214 select a first key 234 and a first key 234 from the key 172 supplied by the main key register 142 respectively. Second key 236. In one embodiment, the bits provided by the extraction address 134 are applied to the multiplexer 212/214 to generate a specific key pair (234/236 key pair) combination. In the embodiment shown in FIG. 2, the number of master key registers 142 provisioned is five, so there are ten possible sets of key pairs. To simplify the hardware design, only 8 of these groups are used; this design will supply a valid key of 2048 bytes, which will be discussed in detail in subsequent paragraphs. However, other implementations may use other numbers of key registers 142 . Taking the embodiment of supplying 12 master key registers 142 as an example, there are 66 possible combinations of master key registers 142, and if 64 of them are used, the generated effective key will be 16384 bytes. In general, assuming that the total number of the above-mentioned multiple key values is K (for example: 5, and all combinations are used), the length of the decryption key and the above-mentioned multiple key values is W bytes (for example: 16 words section), then the resulting effective key will be W ² *(K!/(2*(K-2)!)) bytes. The process then proceeds to block 306 .

At block 306 , based on bits [7:4] of the extraction address 134 , the rotator 216 rotates the first key 234 by a corresponding number of bytes. For example, if bits [7:4] of the extraction address 134 have a value of 9, the rotator 216 rotates the first key 234 to the right by 9 bytes. The flow then goes to block 308 .

At block 308 , the adder/subtractor 218 adds/subtracts the rotated first key 238 to/from the second key 236 to generate the decryption key 174 of FIG. 1 . In one embodiment, if the bit [7] of the extraction address 134 is 1, the adder/subtractor 218 adds the rotated first key 234 to the second key 236; if the bit [7] of the extraction address 134 is [ 7] is 0, the adder/subtractor 218 subtracts the rotated first key 234 from the second key 236 . Then, the process enters block 312 .

In the decision block 312, the multiplexer 154 judges whether the extracted command data 106 of the block is from an encrypted program or a plain text program according to its control signal from the bit E 148 supplied by the control register 144. If the instruction data 106 is encrypted, the process enters block 314 , otherwise, the process enters block 316 .

At block 314 , the multiplexer 154 selects the output decryption key 174 , and the exclusive logic 156 performs a Boolean XOR operation on the encrypted command data 106 and the decryption key 174 to generate the plain text command data 162 of FIG. 1 . Flow ends at block 314 .

In block 316, the multiplexer 154 selects to output the 16-byte binary zero value 176, and the exclusive logic 156 makes the command data 106 (which is plain text) and the 16-byte binary zero value perform a Boolean XOR operation, to generate the same plain text instruction data 162. The flow ends at this block 316 .

2 and 3, the decryption key 174 is supplied to the extracted block command data 106 for exclusive operation, and the decryption key 174 is the selected master key pair 234/236 and the extraction address 134 The function. Compared to traditional decryption procedures - making the decryption key a function of previous key values, where the key is continuously revised to provide new ones for the next working interval - the decryption technique disclosed in the present invention is completely different. The method of obtaining the decryption key 174 as a function of the master key pair 234/236 and the extraction address 134 has at least the following two advantages. First, as discussed above, the extraction of the encrypted command data and the plain text command data 106 takes the same amount of time and does not increase the operating clock required by the microprocessor 100 . Second, the time required to fetch instruction data 106 does not increase when a branch instruction (branch instruction) in the program is encountered. In one embodiment, a branch predictor (branch predictor) receives the fetch address 134, and predicts whether there is a branch instruction in the instruction data 106 of the block pointed by the fetch address 134, and predicts its direction and target address. Taking the embodiment shown in FIG. 2 as an example, the decryption key 174 produced is a function of the master key pair 234/236 and the extraction address 134, and the block instruction data 106 pointed to by the target address is sent to the corresponding block. At the same time the logic 156 produces the appropriate decryption key 174 for the predicted target address. Compared with the multiple "rewind" steps necessary to calculate the decryption key for the target address in the traditional decryption key calculation method, the technology disclosed in the present invention does not generate additional delay when processing encrypted command data.

In addition, as shown in FIG. 2 and FIG. 3 , the combined design of the rotator 216 and the adder/subtractor 218 of the key expander 152 makes the length of the decryption key effectively extend beyond the length of the master key. For example, the master key contributes a total of 32 bytes (2*16 bytes); moreover, from the perspective of a hacker attempting to determine what the decryption key 174 is, the rotator 216 and the adder/subtractor 218 will effectively be located in the master key. The 32-byte master key of the key register 142 is expanded into a 256-byte key sequence. More specifically, byte n of the effective extended key sequence is:

${\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="k"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">k</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; no</span>}}}<span\; class="notranslate">\; \&PlusMinus;</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="1"\; label="k"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">k</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 1</span>}}_{\mathrm{<span\; class="notranslate">\; no</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; x</span>}}}$

为第一主密钥234的字节n，且

为第二主密钥的字节n+x。如上所述，密钥扩展器152所产生的前八套16字节解密密钥174是由减法方式产生，且后八套是由加法方式产生。具体来说，选定的主密钥对234/236各自所提供的字节内容用于为16个连续的16字节区块的指令数据各个字节产生解密密钥174字节，详情请见表格3。举例说明，表格3第1列的符号”15-00”表示第二主密钥236的字节0的内容会经8位算数运算(an eight-bit arithmetic operation)自第一主密钥234的字节15减去，以获得一字节的有效解密密钥174，用以与一16字节区块的指令数据106中的字节15进行异运算。

is byte n of the first master key 234, and

is byte n+x of the second master key. As mentioned above, the first eight sets of 16-byte decryption keys 174 generated by the key expander 152 are generated by subtraction, and the last eight sets are generated by addition. Specifically, the byte content provided by the selected master key pair 234/236 is used to generate a decryption key 174 bytes for each byte of instruction data of 16 consecutive 16-byte blocks. For details, see Form 3. For example, the symbol "15-00" in the first column of Table 3 indicates that the content of byte 0 of the second master key 236 will be obtained from the first master key 234 through 8-bit arithmetic operation (an eight-bit arithmetic operation) Byte 15 is subtracted to obtain a one-byte effective decryption key 174 for exclusive operation with byte 15 in command data 106 of a 16-byte block.

15-00 14-15 13-14 12-13 11-12 10-11 09-10 08-09 07-08 06-07 05-06 04-05

03-04 02-03 01-02 00-01

15-01 14-00 13-15 12-14 11-13 10-12 09-11 08-10 07-09 06-08 05-07 04-06

03-05 02-04 01-03 00-02

15-02 14-01 13-00 12-15 11-14 10-13 09-12 08-11 07-10 06-09 05-08 04-07

03-06 02-05 01-04 00-03

15-03 14-02 13-01 12-00 11-15 10-14 09-13 08-12 07-11 06-10 05-09 04-08

03-07 02-06 01-05 00-04

15-04 14-03 13-02 12-01 11-00 10-15 09-14 08-13 07-12 06-11 05-10 04-09

03-08 02-07 01-06 00-05

15-05 14-04 13-03 12-02 11-01 10-00 09-15 08-14 07-13 06-12 05-11 04-10

03-09 02-08 01-07 00-06

15-06 14-05 13-04 12-03 11-02 10-01 09-00 08-15 07-14 06-13 05-12 04-11

03-10 02-09 01-08 00-07

15-07 14-06 13-05 12-04 11-03 10-02 09-01 08-00 07-15 06-14 05-13 04-12

03-11 02-10 01-09 00-08

15+08 14+07 13+06 12+05 11+04 10+03 09+02 08+01 07+00 06+15 05+14

04+13 03+12 02+11 01+10 00+09

15+09 14+08 13+07 12+06 11+05 10+04 09+03 08+02 07+01 06+00 05+15

04+14 03+13 02+12 01+11 00+10

15+10 14+09 13+08 12+07 11+06 10+05 09+04 08+03 07+02 06+01 05+00

04+15 03+14 02+13 01+12 00+11

15+11 14+10 13+09 12+08 11+07 10+06 09+05 08+04 07+03 06+02 05+01

04+00 03+15 02+14 01+13 00+12

15+12 14+11 13+10 12+09 11+08 10+07 09+06 08+05 07+04 06+03 05+02

04+01 03+00 02+15 01+14 00+13

15+13 14+12 13+11 12+10 11+09 10+08 09+07 08+06 07+05 06+04 05+03

04+02 03+01 02+00 01+15 00+14

15+14 14+13 13+12 12+11 11+10 10+09 09+08 08+07 07+06 06+05 05+04

04+03 03+02 02+01 01+00 00+15

15+15 14+14 13+13 12+12 11+11 10+10 09+09 08+08 07+07 06+06 05+05

04+04 03+03 02+02 01+01 00+00

Form 3

Given an appropriate master key value, the expanded key statistics generated by the key expander 152 can effectively prevent common attacks in different encryptions, including shifting the encrypted block of the file by the key length, and changing the encryption area Blocks are XORed together, discussed in more detail below. The effect of the key expander 152 on the selected master key pair 234/236 is: in the described embodiment, the span of two instruction data 106 bytes encrypted with the same key in the program can be as high as 256 bytes. byte. In other implementations with command data 106 of different block sizes and different master key lengths, the maximum span of two command data 106 bytes encrypted with the same key may have different amounts.

The master key register 142 used to select the master key pair 234/236 and the multiplexers 212/214 in the key expander 152 also determine the degree of expansion of the effective key length. As discussed above, the embodiment shown in FIG. 2 is supplied with five master key registers 142, and the contents supplied by the master key registers 142 can therefore be combined in 10 ways, and the multiplexers 212/214 are used to select from the above 10 ways. Choose from eight effects in possible combinations. After the 256-byte effective key length corresponding to each key pair 234/236 shown in Table 3 is combined with the eight master key pairs 234/236, the resulting effective key length is 2048 bytes. That is to say, the span of 106 bytes of two instruction data encrypted with exactly the same key in the program can be as high as 2048 bytes.

In order to further illustrate the advantages brought by the key expander 152, the common attacks of different encryption programs are briefly described below. If the length of the key used in the different encryption operation is shorter than the length of the encrypted/decrypted program instruction data, many bytes in the key must be reused, and the number of bytes to be reused depends on the length of the program. This weakness makes the encryption program of different instructions crackable. First, the hacker tries to determine the length of the repeated key, let it be n+1 in the descriptions (1) to (3) shown below. Second, the hacker assumes that each key-length block in the command data is encrypted with the same key. The following enumerates the data of the two-key length block encrypted according to a traditional heterogeneous encryption operation:

$<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 1</span>}<span\; class="notranslate">\; )</span>{\mathrm{<span\; class="notranslate">\; b</span>}}_{{\mathrm{<span\; class="notranslate">\; no</span>}}_{\mathrm{<span\; class="notranslate">\; 0</span>}}}<span\; class="notranslate">\; ^</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; ,</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="1"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 1</span>}}_{\mathrm{<span\; class="notranslate">\; 0</span>}}}<span\; class="notranslate">\; ^</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="1"\; label="k"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">k</figure-callout></span>}}_{\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; 0</span>}}}<span\; class="notranslate">\; ^</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="k"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">k</figure-callout></span>}}_{\mathrm{<span\; class="notranslate">\; 0</span>}}$

$<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 1</span>}<span\; class="notranslate">\; )</span>{\mathrm{<span\; class="notranslate">\; b</span>}}_{{\mathrm{<span\; class="notranslate">\; no</span>}}_{\mathrm{<span\; class="notranslate">\; 1</span>}}}<span\; class="notranslate">\; ^</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{\mathrm{<span\; class="notranslate">\; no</span>}}<span\; class="notranslate">\; ,</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="1"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 1</span>}}_{\mathrm{<span\; class="notranslate">\; 1</span>}}}<span\; class="notranslate">\; ^</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="1"\; label="k"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">k</figure-callout></span>}}_{\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; 1</span>}}}<span\; class="notranslate">\; ^</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="k"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">k</figure-callout></span>}}_{\mathrm{<span\; class="notranslate">\; 0</span>}}$

为第一密钥长度区块的数据的字节n，将被加密；为第二密钥长度区块的数据的字节n，将被加密；且k_n为密钥的字节n。第三，黑客对所述两区块进行异运算，使其中密钥成分彼此相销，独留以下内容：in,

Byte n of the data of the first key length block will be encrypted; is byte n of the data of the second key length block to be encrypted; and k _n is byte n of the key. Thirdly, the hacker performs XOR operation on the two blocks, so that the key components in them cancel each other, leaving only the following content:

$<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 3</span>}<span\; class="notranslate">\; )</span>{\mathrm{<span\; class="notranslate">\; b</span>}}_{{\mathrm{<span\; class="notranslate">\; no</span>}}_{\mathrm{<span\; class="notranslate">\; 0</span>}}}<span\; class="notranslate">\; ^</span>{\mathrm{<span\; class="notranslate">\; b</span>}}_{{\mathrm{<span\; class="notranslate">\; no</span>}}_{\mathrm{<span\; class="notranslate">\; 1</span>}}}<span\; class="notranslate">\; ,</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="1"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 1</span>}}_{\mathrm{<span\; class="notranslate">\; 0</span>}}}<span\; class="notranslate">\; ^</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="1"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 1</span>}}_{\mathrm{<span\; class="notranslate">\; 1</span>}}}<span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; 0</span>}}}<span\; class="notranslate">\; ^</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; 1</span>}}}$

Finally, since the calculated bytes are simply a function of two plain text bytes, hackers can statistically analyze the occurrence frequency of plain text content to try to obtain the value of plain text bytes.

However, the pattern of 106 bytes of encrypted instruction data calculated according to the method disclosed in FIG. 2 and FIG. 3 is shown in the following explanations (4) and (5):

$<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 4</span>}<span\; class="notranslate">\; )</span>{\mathrm{<span\; class="notranslate">\; b</span>}}_{{\mathrm{<span\; class="notranslate">\; no</span>}}_{\mathrm{<span\; class="notranslate">\; 0</span>}}}<span\; class="notranslate">\; ^</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{{\mathrm{<span\; class="notranslate">\; no</span>}}_{\mathrm{<span\; class="notranslate">\; x</span>}}}<span\; class="notranslate">\; \&PlusMinus;</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="k"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">k</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; the\; y</span>}}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ,</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="1"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 1</span>}}_{\mathrm{<span\; class="notranslate">\; 0</span>}}}<span\; class="notranslate">\; ^</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{{\mathrm{<span\; class="notranslate">\; 1</span>}}_{\mathrm{<span\; class="notranslate">\; x</span>}}}<span\; class="notranslate">\; \&PlusMinus;</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="2"\; label="k"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">k</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 2</span>}}_{\mathrm{<span\; class="notranslate">\; the\; y</span>}}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; 0</span>}}}<span\; class="notranslate">\; ^</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; x</span>}}}<span\; class="notranslate">\; \&PlusMinus;</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="1"\; label="k"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">k</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 1</span>}}_{\mathrm{<span\; class="notranslate">\; the\; y</span>}}}<span\; class="notranslate">\; )</span>$

$<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 5</span>}<span\; class="notranslate">\; )</span>{\mathrm{<span\; class="notranslate">\; b</span>}}_{{\mathrm{<span\; class="notranslate">\; no</span>}}_{\mathrm{<span\; class="notranslate">\; 1</span>}}}<span\; class="notranslate">\; ^</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{{\mathrm{<span\; class="notranslate">\; no</span>}}_{\mathrm{<span\; class="notranslate">\; x</span>}}}<span\; class="notranslate">\; \&PlusMinus;</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="1"\; label="k"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">k</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 1</span>}}_{\mathrm{<span\; class="notranslate">\; the\; y</span>}}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ,</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="1"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 1</span>}}_{\mathrm{<span\; class="notranslate">\; 1</span>}}}<span\; class="notranslate">\; ^</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{{\mathrm{<span\; class="notranslate">\; 1</span>}}_{\mathrm{<span\; class="notranslate">\; x</span>}}}<span\; class="notranslate">\; \&PlusMinus;</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{{\mathrm{<span\; class="notranslate">\; 3</span>}}_{\mathrm{<span\; class="notranslate">\; the\; y</span>}}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; 1</span>}}}<span\; class="notranslate">\; ^</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; x</span>}}}<span\; class="notranslate">\; \&PlusMinus;</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="2"\; label="k"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">k</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 2</span>}}_{\mathrm{<span\; class="notranslate">\; the\; y</span>}}}<span\; class="notranslate">\; )</span>$

标示所加密的第二16字节区块的指令数据的字节n，标示主密钥x的字节n，且

标示主密钥y的字节n。如前述，主密钥x与y为不同密钥。假定一种实施方式以五个主密钥寄存器142提供八种主密钥对234/236组合，2048字节序列中各字节是与两个独立的主密钥字节的一组合进行异运算。因此，当加密数据以任何方式于256字节的区块中移位并且彼此作异运算，所求得的字节都会存在两个主密钥的复杂成分，因此，不若说明(3)的内容，此处所得的运算结果不单纯只是纯文字字节。例如，假设黑客选择使同一256字节区块中的16字节区块对齐并彼此进行异操作使同样的密钥零字节在各段中被使用，字节0的运算结果如说明(6)所示，所获得的字节存在两个主密钥的复杂组合：in Byte n designating the instruction data of the encrypted first 16-byte block,

Byte n designating the instruction data of the encrypted second 16-byte block, identifies the byte n of the master key x, and

Indicates the byte n of the master key y. As mentioned above, the master keys x and y are different keys. Assuming that an implementation provides eight master key pairs 234/236 combinations with five master key registers 142, each byte in the 2048 byte sequence performs an exclusive operation with a combination of two independent master key bytes . Therefore, when the encrypted data is shifted in any way in the 256-byte block and XORed with each other, the obtained bytes will have the complex components of the two master keys, so it is not necessary to explain (3) Content, the operation result obtained here is not just pure text bytes. For example, assuming that the hacker chooses to align 16-byte blocks in the same 256-byte block and XOR each other so that the same key zero byte is used in each segment, the operation result of byte 0 is as described in (6 ), the obtained bytes are a complex combination of two master keys:

$<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 6</span>}<span\; class="notranslate">\; )</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; 0</span>}}}<span\; class="notranslate">\; ^</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; x</span>}}}<span\; class="notranslate">\; \&PlusMinus;</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="1"\; label="k"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">k</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 1</span>}}_{\mathrm{<span\; class="notranslate">\; the\; y</span>}}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ^</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; 1</span>}}}<span\; class="notranslate">\; ^</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; x</span>}}}<span\; class="notranslate">\; \&PlusMinus;</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{{\mathrm{<span\; class="notranslate">\; no</span>}}_{\mathrm{<span\; class="notranslate">\; the\; y</span>}}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ,</span>$

where n is not 1.

Furthermore, if the hacker instead aligns 16-byte blocks selected from different 256-byte blocks and performs exclusive operations with each other, the byte 0 of the operation result is as shown in the description (7):

$<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 7</span>}<span\; class="notranslate">\; )</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; 0</span>}}}<span\; class="notranslate">\; ^</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; x</span>}}}<span\; class="notranslate">\; \&PlusMinus;</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="1"\; label="k"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">k</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 1</span>}}_{\mathrm{<span\; class="notranslate">\; the\; y</span>}}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ^</span>{\mathrm{<span\; class="notranslate">\; <figure-callout\; id="0"\; label="b"\; filenames="HDA0000063520780000092.png"\; state="\{\{state\}\}">b</figure-callout></span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; 1</span>}}}<span\; class="notranslate">\; ^</span><span\; class="notranslate">\; (</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{{\mathrm{<span\; class="notranslate">\; 0</span>}}_{\mathrm{<span\; class="notranslate">\; u</span>}}}<span\; class="notranslate">\; \&PlusMinus;</span>{\mathrm{<span\; class="notranslate">\; k</span>}}_{{\mathrm{<span\; class="notranslate">\; no</span>}}_{\mathrm{<span\; class="notranslate">\; v</span>}}}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ,</span>$

呈现相当平滑的分布。Wherein at least one of master keys u and v is different from master keys x and y. Simulate the exclusive operation of the effective key bytes generated by the random master key value, and the operation result can be found

presents a fairly smooth distribution.

Of course, if the hacker chooses to align the 16-byte blocks in different 2048-byte length blocks and perform XOR operations with each other, the hacker may obtain a result similar to that in description (3). However, please refer to the following. First, some programs - eg, security-related programs - may be shorter than 2048 bytes. Second, the statistical correlation of instruction bytes 2048 bytes apart is likely to be very small, making it difficult to crack. Third, as mentioned above, the embodiment of the technology can implement a large number of master key registers 142, so that the effective length of the decryption key can be expanded; key, or even other longer decryption keys. Fourth, the key download instruction 500 and the key switch instruction 600 discussed below enable the programmer to load new values into the master key register 142 to effectively extend the key length beyond 2048 bytes, or if The key length can also be extended to the full length of the program if necessary.

Referring now to FIG. 4, a block diagram illustrates the flag register 128 of FIG. 1 in accordance with the teachings of the present invention. According to the embodiment shown in FIG. 4, the flag register 128 includes a plurality of bits 408 of a standard x86 register; however, for the new functions described here, the embodiment shown in FIG. one of. In particular, the flag register 128 includes an E-bit field 402 . The E-bit field 402 is used to restore the value of the E-bit 148 of the control register 144 for switching between encryption and plain text programs and/or switching between different encryption programs, as will be discussed in detail below. The E-bit field 402 indicates whether the currently executed program is encrypted. If the currently executed program has encryption, the E bit field 402 is set, otherwise, it is cleared. When an interrupt event occurs, the control is switched to other programs (for example, an interrupt, an exception such as a page fault, or a task switch), and the flag register 128 is stored. On the contrary, if the control is returned to the program that was previously interrupted by the interrupt event, then the flag register 128 is repaired. The microprocessor 100 is designed to update the value of the E-bit 148 of the control register 144 with the value of the E-bit 402 field of the flags register 128 when the flags register 128 is repaired, as will be discussed in detail below. Therefore, if an encryption program is being executed (that is, the extraction unit 104 is in the decryption mode) when an interrupt event occurs, when the control right is returned to the encryption program, the E bit 148 is set to a set state with the repaired E bit field 402 to repair Extraction unit 104 is in decryption mode. In one embodiment, the E bit 148 and the E bit field 402 are the same specific hardware bit, therefore, storing the value in the E bit field 402 of the flag register 128 means storing the E bit 148, and repairing the E bit of the flag register 128 The value of field 402 is the repair E bit 148 .

Referring to FIG. 5, a block diagram illustrates the format of a key download command 500 implemented in accordance with the techniques of the present invention. The key download command 500 includes an opcode 502 field, specifically marking it as the key download command 500 in the instruction set of the microprocessor 100 . In one embodiment, the opcode field 502 has a value of 0FA6/4 (x86 domain). The key download instruction 500 includes two operands: a key register file target address 504 and a secure storage area source address 506 . The secure storage area source address 506 is an address in the secure storage area 122 storing a 16-byte master key. The key register file address 504 indicates the address of a register in the key register file 124 that will be loaded with the 16-byte master key loaded from the secure storage area 122 . In one embodiment, if a program attempts to execute the key load instruction 500 when the microprocessor 100 is not in a safe operation mode, it is regarded as an invalid instruction exception; Outside the secure storage area 122, it is regarded as a general protection exception. In one embodiment, if a program attempts to execute the key download instruction 500 when the microprocessor 100 is not at the highest privilege level (for example, x86 ring 0 privilege/x86 ring 0), it is considered an invalid instruction exception. In some cases, the composition of the 16-byte master key may be included in the immediate data field of the encryption command. The instant data can be moved to the secure storage area 122 block by block to form a 16-byte key.

Referring now to FIG. 6, a block diagram illustrates the format of a key switch command 600 implemented in accordance with the techniques of the present invention. The key switching instruction 600 includes an opcode 602 field, specifically it is the key switching instruction 600 in the instruction set of the microprocessor 100 . The key switch instruction 600 also includes a key register file index field 604 that identifies the beginning of a sequence of registers in the key register file 124 from which to load the key into the master key register 142 . In one embodiment, if a program attempts to execute a key switching instruction 600 when the microprocessor 100 is not in the secure operating mode, it is considered an invalid instruction exception. In one embodiment, if a program intends to execute a key switching instruction 600 when the microprocessor 100 is not at the highest privilege level (for example, x86 ring 0 privilege), it is regarded as an invalid instruction exception. In one embodiment, key switching instruction 600 is atomic, i.e., non-interruptible; the same is true for other instructions for loading a key into master key register 142 as discussed herein—for example, the following Discuss the branch and switch key instructions.

Referring now to FIG. 7, a flowchart illustrates the operation of the microprocessor 100 of FIG. 1 in which the key switching instruction 600 introduced in FIG. 6 is executed in accordance with the teachings of the present invention. Flow begins at block 702 .

In block 702 , the decoding unit 108 decodes a key switching instruction 600 , and substitutes the decoding result into the microcode program in the microcode unit 132 to implement the key switching instruction 600 . The flow then goes to block 704 .

At block 704 , the microcode downloads the contents of the master key register 142 from the key register file 124 according to the key register document index field 604 . A preferred embodiment is: the microcode starts with the key register indicated by the key register file index field 604, and downloads the contents of n consecutive registers from the key register file 124 as n keys and stores them in the master key register 142, where n is the total number of master key registers 142. In one embodiment, the value n may indicate an extra space in the key switching command 600 , which is set to be less than the total number of master key registers 142 . The process then proceeds to block 706 .

At block 706, the microcode causes the microprocessor 100 to branch to the next x86 instruction (i.e., the instruction after the key switch instruction 600), which will cause all x86 instructions in the microprocessor 100 that are newer than the key switch instruction 600 to be cleared , so that all micro-operations in the microprocessor 100 that are newer than the micro-operations switched to the subsequent x86 instructions are cleared. The cleared instructions include all instruction bytes 106 fetched from the instruction cache 102 , buffered and temporarily stored in the fetch unit 104 and the decode unit 108 waiting to be decrypted and decoded. The process then proceeds to block 708 .

At block 708 , based on the operation of the block 706 branch to the next instruction, the fetch unit 104 begins fetching and decrypting the instruction data 106 from the instruction cache 102 using the new set of key values loaded into the master key register 142 at block 704 . Flow ends at block 708 .

As shown in FIG. 7 , the key switching instruction 600 enables the encrypted program being executed to change the content stored in the master key register 142 for decrypting the encrypted program while being fetched from the instruction cache 102 . The dynamic adjustment technology of the master key register 142 makes the length of the effective key for encrypting the program exceed the length supported by the extracting unit 104 (for example, 2048 bytes provided by the embodiment of FIG. 2 ); By operating it with the microprocessor 100 shown in FIG. 1 , it will be more difficult for hackers to break through the security protection of the computer system.

Referring now to FIG. 8, a block diagram illustrates a memory footprint 800 of an encryption program implemented according to the techniques of the present invention, wherein the key switching instruction 600 shown in FIG. 6 is employed. The encrypted program memory usage 800 shown in FIG. 8 includes a consecutive number of "chunks" of instruction data bytes. The content of each "block" is a sequence of multiple command data bytes (which are pre-encrypted data), and the command data bytes belonging to the same "block" are decrypted by the same set of master key register 142 values. Therefore, the boundary between two different "blocks" is defined by the key switch command 600 . That is to say, the upper and lower bounds of each "block" are distinguished by the position of the key switching instruction 600 (or, taking the first "block" of a program as an example, the upper bound is the beginning of the program; in addition, Take the last "block" of the program, for example, whose lower bound is the end of the program). Therefore, each "block" of command data bytes is decrypted by the extraction unit 104 based on a different set of master key register 142 values, meaning that each "block" of command data bytes is decrypted according to a key supplied by the previous "block". The value loaded into the master key register 142 by the key switching instruction 600. The post-processor (post-processor) of an encryption program will know the memory address where each key switching instruction 600 is located, and will use this information—that is, extract the relevant address bits of the address—combined with the key value of the key switching instruction 600 to generate encryption key bytes to encrypt the program. Some object file formats allow the programmer to indicate where the program is loaded into memory, or at least specify a specific size alignment (eg, page boundary) to provide sufficient address information to encrypt the program. Also, some operating systems default to loading programs on page boundaries.

The key switching instruction 600 can be placed anywhere in the program. However, if the key switch instruction 600 loads a specific value into the master key register 142 for decryption of the next "block" of command data bytes, and the location of the key switch instruction 600 (or even the key load instruction 500) results in The length of each "block" is shorter than or equal to the effective key length that the extracting unit 104 can handle (for example, 2048 bytes disclosed in the embodiment shown in FIG. Key encryption, which is a fairly strong encryption method. Furthermore, even though the use of the key switching instruction 600 results in an effective key length that is still shorter than the length of the encryption program (i.e., the same set of master key register 142 values is used to encrypt multiple "blocks" of a program), changing " The "block" size (for example, not limited to 2048 bytes) can increase the difficulty for hackers to crack the system, because the hacker must first determine where the "block" encrypted with the same set of master key register 142 values is located, and must determine The respective dimensions of the "blocks" of varying lengths.

It is worth noting that dynamic key switching implemented with the key switching instruction 600 consumes a relatively large number of clocks, mainly because the pipeline must be flushed. Furthermore, in one embodiment, the key switching instruction 600 is implemented primarily in microcode, which is generally slower than instructions implemented in non-microcode. Therefore, program code developers must consider the impact of key switching instructions on performance, and seek a balance between execution speed and security considerations for specific applications.

Referring now to FIG. 9, a block diagram illustrates the format of a branch and switch key instruction 900 implemented in accordance with the techniques of the present invention. First, the necessity of the branch and switch key instruction 900 is described.

According to the content disclosed in the above embodiments, the instruction data of each 16-byte block extracted by the extraction unit 104 after the encryption program is encrypted first (differentiation technology), and the encryption key used is equivalent to that used by the extraction unit 104. Each 16-byte decryption key 174 of the extracted command data 106 of each block is decrypted (exclusive operation). As mentioned above, the byte value of the decryption key 174 is calculated by the extraction unit 104 based on the following two inputs: the byte value of the master key stored in the master key register 142, and the extracted 16-byte field Some bits of the fetch address 134 of the instruction data 106 of the block (take the embodiment disclosed in FIG. 2 as an example, bits [10:4]). Thus, encrypting a program enables a post-processor executed by microprocessor 100 to know the master key byte value to be stored in master key register 142, as well as an address (or more limited to a number associated with the address). bit); the address indicates where the encrypted program will be loaded into the memory, and the microprocessor 100 will sequentially extract the instruction data of several blocks of the encrypted program from here. Based on the above information, the post-processor can properly generate the value of the decryption key 174 for encrypting the instruction data of each 16-byte block of the program.

As discussed above, when a branch instruction is predicted and/or executed, the fetch unit 104 updates the fetch address 134 with the branch target address. The branch instruction is transparently controlled by the fetch unit 104 as long as the encryption program never changes (via the key switching instruction 600 ) the master key value stored in the master key register 142 . That is to say, the extraction unit 104 will use the same value of the master key register 142 to estimate the decryption key 174 for decrypting the instruction data 106 of a block including the branch instruction and decrypting the target address of the branch instruction. Commands within the command data 106 of a block. However, the ability of the program to change (via the key switch instruction 600) the value of the master key register 142 means that it is possible for the fetch unit 104 to estimate the decryption key 174 with a set of master key register 142 values to decrypt a block containing the branch instruction The instruction data 106 of the branch instruction, and the decryption key 174 is estimated with a different set of master key register 142 values to decrypt the instruction in the instruction data 106 of a block indicated by the target address of the branch instruction. One way to solve this problem is to restrict branch target addresses to the same "block" of the program. Another solution is to use the branch and switch key instruction 900 disclosed in FIG. 9 .

Referring again to FIG. 9, a block diagram illustrates the format of a branch and switch key instruction 900 implemented in accordance with the techniques of the present invention. The branch and switch key instruction 900 includes an opcode 902 field identifying it as a branch and switch key instruction 900 within the instruction set of the microprocessor 100 . The branch and switch key instruction 900 also includes a key register file index field 904 identifying the beginning of a chain of registers in the key register file 124 from which to load the key into the master key register 142 . The branch and switch key instruction 900 also includes a branch information field 906, which records typical information of the branch instruction—for example, the information of calculating the target address and the branch condition. In one embodiment, if a program attempts to execute a branch and switch key instruction 900 when the microprocessor 100 is not in the secure execution mode, it is considered an invalid instruction exception. In one embodiment, if a program attempts to execute the branch and switch key instruction 900 when the microprocessor 100 is not at the highest privilege level (eg, x86 ring 0 privilege), it is treated as an invalid instruction exception. In one embodiment, the branch and switch key instruction 900 is atomic.

Referring to FIG. 10, a flow diagram illustrates the operation of the microprocessor 100 of FIG. 1 in which the branch and switch key instruction 900 disclosed in FIG. 9 is executed in accordance with the teachings of the present invention. Flow begins at block 1002 .

At block 1002 , the decode unit 108 decodes a branch and switch key instruction 900 and substitutes it into the microcode program implementing the branch and switch key instruction 900 in the microcode unit 132 . The flow then enters block 1006 .

At block 1006, the microcode resolves the branch direction (taken, or not taken), and the target address. It should be noted that, for an unconditional branch instruction (unconditional branch instruction), the direction balance is adopted. The flow then enters into decision block 1008 .

In decision block 1008, the microcode determines whether the direction resolved in block 1006 is adoption. If yes, the process goes to block 1014 . Otherwise, the process goes to block 1012 .

At block 1012, the microcode does not switch keys, or jump to the target address, because the branch operation was not taken. The flow ends at block 1012.

At block 1014 , the microcode loads the key from the key register file 124 into the master key register 142 according to the key register file index field 904 . In a preferred embodiment, the microcode starts from the position indicated by the key register file index field 904, and loads n keys recorded in n adjacent registers in the key register file 124 into the master key register 142, where n is the total number of master key registers 142 . In one embodiment, the value of n can be recorded in an extra space of the branch and switch key instruction 900 and set to a value smaller than the total number of master key registers 142 . The process then proceeds to block 1016 .

In block 1016, the microcode causes the microprocessor 100 to jump to the target address solved in block 1006, which will cause all x86 instructions newer than the branch and switch key instruction 900 in the microprocessor 100 to be cleared, causing the microprocessor 100 All micro-ops within and newer than the micro-op that branched to the target address are cleared. The cleared instructions include all instruction bytes 106 fetched from the instruction cache 102 , buffered and temporarily stored in the fetch unit 104 and the decode unit 108 waiting to be decrypted and decoded. The flow then enters block 1008 .

At block 1018 , following the branch to target address at block 1016 , fetch unit 104 begins fetching and decrypting instruction data 106 from instruction cache 102 using the new set of key values loaded into master key register 142 at block 1014 . Flow ends at block 1018.

Referring now to FIG. 11, a flowchart illustrates the operation of a post-processor implemented in accordance with the techniques of the present invention. The post-processor is a software tool that can be used to post-process a program and encrypt it for execution by the microprocessor 100 of FIG. 1 . Flow begins at block 1102 .

At block 1102, the post-processor receives an object file for a program. According to one embodiment, the target address of the branch instruction in the object file can be determined before program execution; for example, a branch instruction pointing to a fixed target address. There is another form of the branch instruction that determines the target address before the program runs, for example, a relative branch instruction (relative branch instruction), which records an offset, which is used to add the memory address where the branch instruction is located to obtain Branch target address. Conversely, for a branch instruction whose target address will not be determined before program execution, one example is to calculate the target address based on operands stored in registers or memories, so its value may change during program execution. The flow then goes to block 1104 .

At block 1104, the post-microprocessor replaces the inter-chunk branch instruction with the branch and switch key instruction 900, which has an appropriate value stored in the key register file index space 904, the value It is set based on the "block" in which the target address of the branch instruction is located. As shown in FIG. 8 , a "block" is composed of a sequence of multiple instruction data bytes to be decrypted by the same set of master key register 142 values. Therefore, the "block" in which the target address of the cross-block branch instruction is located is different from the "block" of the branch instruction itself. It's worth noting that intra-block branches -- that is, branch instructions whose target address is in the same "block" as itself -- don't have to be replaced. It should be noted that the program design and/or compiler that generates the source file to generate the target file may explicitly include the branch and switch key instruction 900 to reduce the burden of the post-processor replacement operation. The flow then goes to block 1106 .

At block 1106, the post-processor encrypts the program. The post-processor knows the memory location and master key register 142 value of each "block" and uses this to encrypt the program. Flow ends at block 1106 .

Referring now to FIG. 12, a block diagram illustrates the format of a branch and switch key instruction 1200 implemented in another embodiment of the present technology. The branch and switch key instruction 1200 shown in FIG. 12 is suitable for a branch operation whose target address is unknown before program execution, and will be discussed in detail below. The branch and switch key instruction 1200 includes an opcode 1202 field to identify it as a branch and switch key instruction 1200 in the instruction set of the microprocessor 100 . The branch and switch key instruction 1200 also includes a branch information field 906 , which has a function similar to that of the branch and switch key instruction 900 in FIG. 9 . In one embodiment, if a program attempts to execute the branch and switch key instruction 1200 when the microprocessor 100 is not in the secure execution mode, it is treated as an invalid instruction exception. In one embodiment, if a program attempts to execute a branch and switch key instruction 1200 when the microprocessor 100 is not at the highest privilege level (eg, x86 ring 0 privilege), it is treated as an invalid instruction exception. In one embodiment, the branch and switch key instruction 1200 is in atomic form.

Referring now to FIG. 13, a block diagram illustrates a "block" address range table 1300 implemented in accordance with the techniques of the present invention. Form 1300 includes a number of cells. Each unit is associated with a "chunk" of the encryption program. Each cell includes an address range field 1302 and a key register file index field 1304 . The address range field 1302 indicates the memory address range of the corresponding "block". The key register file index field 1304 indicates the register in the key register file 124, and the key value stored in the register pointed to by the index is loaded into the master key register 142 by the branch and switch key instruction 1200 for decryption by the extraction unit 104 The "block" used. As discussed below with reference to FIG. 18 , the table 1300 is loaded into the microprocessor 100 before the branch and switch key instruction 1200 that needs to access the contents of the table 1300 is executed.

Referring now to FIG. 14, a flowchart illustrates the operation of the microprocessor 100 of FIG. 1 in which the branch and switch key instruction 1200 of FIG. 12 is executed in accordance with the teachings of the present invention. Flow begins at block 1402 .

At block 1402 , the decoding unit 108 decodes a branch and switch key instruction 1200 and substitutes it into the microcode program in the microcode unit 132 implementing the branch and switch key instruction 1200 . The process then proceeds to block 1406 .

At block 1406, the microcode resolves the branch direction (taken, or not taken), and finds the target address. The flow then enters decision block 1408 .

At decision block 1408, the microcode determines whether the branch direction resolved in block 1406 is taken. If yes, the process goes to block 1414 . Otherwise, the process goes to block 1412 .

At block 1412, the microcode does not switch keys, or jump to the target address, because the branch was not taken. Flow ends at block 1412 .

In block 1414, the microcode queries the table 1300 shown in FIG. 13 based on the target address solved in block 1406, and obtains the content of the key register file index field 1304 corresponding to the "block" where the target address is located. The microcode then loads the key value from the key register file 124 into the master key register 142 based on the index recorded in the key register file index field 1304 . A preferred embodiment is that the microcode loads n key values stored in n adjacent registers from the key register file 124 into the master key register 142 according to the index stored in the key register file index field 1304, Wherein, n is the total number of master key registers 142 . In one embodiment, the value n may be recorded in an additional field of the branch and switch key instruction 1200 , set to be less than the total number of master key registers 142 . Flow then proceeds to block 1416 .

In block 1416, the microcode causes the microprocessor 100 to branch to the target address solved in block 1406, which will cause all x86 instructions in the microprocessor 100 that are newer than the branch and switch key instruction 1200 to be cleared, causing the microprocessor 100 All micro-ops within and newer than the micro-op that branched to the target address are cleared. The cleared instructions include all instruction bytes 106 fetched from the instruction cache 102 , buffered and temporarily stored in the fetch unit 104 and the decode unit 108 waiting to be decrypted and decoded. The process then proceeds to block 1418 .

At block 1418 , following the branch to target address at block 1416 , fetch unit 104 begins fetching and decrypting instruction data 106 from instruction cache 102 using the new set of key values loaded into master key register 142 at block 1414 . Flow ends at block 1418.

Referring now to FIG. 15, a block diagram illustrates the format of a branch and switch key instruction 1500 implemented in accordance with another embodiment of the present technology. The branch and switch key instruction 1500 shown in FIG. 15 and its operation are similar to the branch and switch key instruction 1200 shown in FIG. 12 . However, instead of loading a key from the key register file 124 into the master key register 142, the branch and switch key instruction 1500 loads a key from the secure storage area 122 into the master key register 142, as discussed below.

Referring now to FIG. 16, a block diagram illustrates a "block" address range table 1600 implemented in accordance with the techniques of the present invention. Table 1600 shown in FIG. 16 is similar to table 1300 shown in FIG. 13 . However, instead of including a key register file index field 1304 , table 1600 includes a secure storage area address field 1604 . The secure storage area address field 1604 records an address in the secure storage area 122, and the key value stored at the address must be loaded into the master key register 142 by the branch and switch key instruction 1500 for the extraction unit 1046 to decrypt the "block is used when . The following discussion refers to FIG. 18 . The table 1600 is loaded into the microprocessor 100 before the branch and switch key instruction 1500 that needs to look up the table 1600 is executed. In one embodiment, the lower bits of the secure store 122 address need not be stored in the secure store address field 1604, particularly because the total amount of locations in the secure store 122 to store a set of keys is relatively large (e.g. , 16 bytes x 5), and the set of keys can be aligned along a set size range.

Referring now to FIG. 17, a flowchart illustrates the operation of the microprocessor 100 of FIG. 1 in which the branch and switch key instruction 1500 of FIG. 15 is executed in accordance with the teachings of the present invention. Flow begins at block 1702 . Many blocks of the flowchart of FIG. 17 are similar to many blocks of FIG. 14 and thus are numbered the same. However, block 1414 is replaced by block 1714, and the microcode looks up the table 1600 of FIG. 16 based on the target address obtained in block 1406 to obtain the value of the secure storage area address field 1604 of the "block" where the target address is located. The microcode then loads the key value from the secure storage area 122 into the master key register 142 according to the value of the secure storage area address field 1604 . A preferred embodiment is that the microcode loads n key values stored in n adjacent 16-byte space positions from the secure storage area 122 into the master key register 142 from the secure storage area address field 1604 value, where n is The total number of master key registers 142. In one embodiment, the value n may be recorded in an additional field in the branch and switch key instruction 1500 , set to be less than the total number of master key registers 142 .

Referring now to FIG. 18, a flowchart illustrates the operation of a post-processor implemented in accordance with another embodiment of the present invention. The post-processor can be used to post-process a program and encrypt it, so as to be executed by the microprocessor 100 of FIG. 1 . Flow begins at block 1802 .

At block 1802, a post-processor receives an object file for a program. According to one embodiment, the branch instruction in the target file may be that the target address is determined before the program is executed, or that the target address cannot be determined before the program is executed. The flow then enters block 1803 .

At block 1803, the post-processor builds the "block" address range table 1300 or 1600 of Figure 13 or Figure 16 to include in the object file. In one embodiment, the operating system loads the table 1300/1600 into the microprocessor 100 prior to loading and executing an encryption program to allow access to the branch and switch key instructions 1200/1500. In one embodiment, the post-processor inserts instructions in the program to load the tables 1300/1600 into the microprocessor 100 before any branch and switch key instructions 1200/1500 are executed. The flow then goes to block 1804 .

At block 1804, similar to the operations previously discussed with respect to block 1104 of FIG. 11 , the postprocessor replaces each cross-block branch instruction whose pre-execution target address can be determined with the branch and switch key instruction 900 of FIG. 9 , instruction 900 The appropriate key register file index field 904 value is recorded based on the "block" where the target address of the branch instruction is located. The flow then enters block 1805 .

In block 1805, the post-processor uses the branch instruction 1200 shown in FIG. 12 or FIG. or 1500 to replace. The process then proceeds to block 1806 .

At block 1806, the post-processor encrypts the program. The postprocessor knows the memory location and master key register 142 value for each "block" that will be used to encrypt the program. Flow ends at block 1806 .

Referring now to FIG. 19, a flow diagram illustrates the operation of the microprocessor 100 of FIG. 1 in which task switching between an encrypted program and a text-only program is handled in accordance with the techniques of the present invention. Flow begins at block 1902 .

At block 1902 , the E bit of the E bit field 402 of the flags register 128 and the E bit 148 of the control register 144 of FIG. 1 are cleared by a reset operation of the microprocessor 100 . The flow then goes to block 1904 .

At block 1904, after initialization by executing its reset microcode, the microprocessor 100 begins to fetch and execute user program instructions (eg, system firmware), which are plain text program instructions. In particular, since the E bit 128 is cleared, as mentioned above, the fetch unit 104 regards the fetched command data 106 as a plain text command. The process then proceeds to block 1906 .

At block 1906, system firmware (eg, operating system, firmware, BIOS, . . . , etc.) receives a request to execute an encryption procedure. In one embodiment, the aforementioned requirement to execute an encryption program is accompanied by, or indicated by, a switch operation to switch to a secure execution mode of the microprocessor 100, as discussed above. In one embodiment, the microprocessor 100 is only allowed to operate in a decrypted mode (ie, the E bit 148 is set) when in the secure execution mode. In one embodiment, the microprocessor 100 is only allowed to operate in decryption mode in system management mode (eg, SSM common in x86 architecture). The flow then goes to block 1908 .

At block 1908, the system software loads the master key register 142 with its initial value, associated with the first "block" in the program to be executed. In one embodiment, the system software executes a key switching instruction 600 to download the key to the master key register 142 . Before loading keys into master key register 142 , the contents of key register file 124 may be loaded by one or more key load instructions 500 . In one embodiment, before the key is loaded into the master key register 142 and the key register file 124, the secure storage area 122 can be written with the key value first, wherein the writing is through a common secure channel Techniques such as AES or RSA encrypt the channel to prevent hackers from snooping on its value. As discussed above, the above key values may be stored in a secure non-volatile memory (such as flash memory) coupled to the microprocessor 100 via an isolated serial bus (private serial bus), or may be stored in a microprocessor 100 A non-volatile write-once memory of the processor 100. As discussed above, the procedures may be contained within a single "chunk." That is to say, the program may not include the key switching instruction 600 , and the entire program may be decrypted by a single set of master key register 142 values. Flow then proceeds to block 1916 .

At block 1916, as control is transferred to the encrypted program, the microprocessor 100 sets the E bit field 402 of the flag register 128 to indicate that the currently executing program is encrypted, and sets the E bit 148 of the control register 144 to enable extraction Unit 104 is in decryption mode. The microprocessor 100 further causes the instructions in the pipeline to be flushed, which is similar to the flushing operation performed by block 706 in FIG. 7 . The process then proceeds to block 1918 .

At block 1918 , the fetch unit 104 fetches the instructions 106 in the encrypted program, and decrypts and executes them in a decrypted mode with reference to the techniques disclosed in FIGS. 1-3 . The flow then goes to block 1922 .

At block 1922, while the microprocessor 100 is fetching and executing the encryption program, the microprocessor 100 receives an interrupt event. For example, the interrupt event may be an interrupt, an exception (such as a page fault), or a task switch. When an interrupt event occurs, all pending instructions in the pipeline of the microprocessor 100 are flushed. So, if there are any previously fetched encrypted instructions in the pipeline, it is flushed. In addition, all instruction bytes fetched from the instruction cache 102 that may be cached in the fetch unit 104 and the decode unit 108 waiting to be decrypted and decoded are cleared. In one embodiment, microcode is invoked in response to an interrupt event. The process then proceeds to block 1924 .

At block 1924, the microprocessor 100 stores the flags register 128 (and other structural state of the microprocessor 100, including the current instruction index value of the interrupted encryption routine) to a stack memory. Storing the encrypted program's E-bit field 402 value allows it to be restored in subsequent operations (at block 1934). Flow then proceeds to block 1926 .

At block 1926, when control is transferred to a new program (e.g., an interrupt handler, an exception handler, or a new task), the microprocessor 100 clears the E bit field 402 of the flags register 128, and the control register 144 The E bit is 148 to cope with text-only new programs. That is to say, the embodiment shown in FIG. 19 assumes that the microprocessor 100 is only allowed to run one encryption program at a time, and an encryption program is already executing (but interrupted). Figures 22 to 26 additionally disclose other implementations. The process then proceeds to block 1928 .

At block 1928 , the fetch unit 104 fetches the instructions 106 of the new program in plain text mode with reference to the contents disclosed in FIGS. 1-3 . In particular, the clear state of the E bit 148 in the control register 144 enables the multiplexer 154 to perform an XOR operation on the instruction data 106 and the multi-bit binary zero value 176 so that the instruction data 106 is not decrypted. The process then proceeds to block 1932 .

At block 1932, the new program performs a return operation from an interrupt instruction (eg, x86 IRET) or similar instruction, so that control returns to the encryption program. In one embodiment, the operation of returning from the interrupt instruction is implemented by microcode. The process then proceeds to block 1934 .

In block 1934, in response to the aforementioned operation returning from the interrupt instruction, since the control right is transferred back to the encryption program, the microprocessor 100 repairs the flag register 128, so that the E bit field 402 of the flag register 128 returns to the setting stored in the previous block 1924 state. The process then proceeds to block 1938 .

At block 1938, since the control right is transferred back to the encrypted program, the microprocessor 100 updates the E bit 148 of the control register 144 with the value of the E bit field 402 of the flag register 128, so that the extraction unit 104 re-fetches and decrypts the instruction data of the encrypted program 106. The process then proceeds to block 1942 .

At block 1942, the microcode causes the microprocessor 100 to branch to the instruction index value stored in the stack memory at the previous block 1924, causing all x86 instructions in the microprocessor 100 to be cleared and all micro-operations in the microprocessor 100 to be cleared . The cleared content includes all instruction bytes 106 fetched from the instruction cache memory 102 , buffered and temporarily stored in the fetch unit 104 and the decoding unit 108 waiting to be decrypted and decoded. The process then proceeds to block 1944 .

At block 1944, the fetch unit 104 resumes fetching the instructions 106 in the encrypted program, and decrypts and executes them in a decrypted mode with reference to the techniques disclosed in FIGS. 1-3 . Flow ends at block 1944.

Referring now to FIG. 20, a flowchart illustrates the operation of a system software implemented in accordance with the techniques of the present invention, executed by the microprocessor 100 of FIG. The process in FIG. 20 can be executed in combination with the content in FIG. 19 . The process starts at block 2002.

At block 2002, the system software receives a request to execute a new encryption procedure. The flow then enters decision block 2004 .

At decision block 2004, the system software determines whether the encrypted program is one of the programs already being executed by the system. In one embodiment, the system software uses a flag to indicate whether an encryption program is one of the programs already executing in the system. If the encryption program is one of the programs already being executed by the system, the flow goes to block 2006 , otherwise, the flow goes to block 2008 .

At block 2006, the system software waits for the encryption program to finish executing and is no longer one of the programs being executed by the system. The flow then enters block 2008 .

At block 2008, the microprocessor 100 allows the new encryption program to begin execution. The process ends at block 2008.

Referring now to FIG. 21, a block diagram illustrates the fields of the flag register 128 of FIG. 1 in accordance with another embodiment of the present technology. The flag register 128 in FIG. 21 is similar to the embodiment shown in FIG. 4 , but also includes an index field (index bits) 2104. According to one embodiment, the index field 2104 and the E bit 402 are generally reserved by the x86 architecture. The index field 2104 is used to cope with switching between multiple encryption programs, which will be discussed in detail below. In a preferred embodiment, the key switch instruction 600 and the branch and switch key instruction 900/1200 update the index field 2104 of the flag register 128 with their own key register index field 604/904/1304.

Referring now to FIG. 22, a flow diagram illustrates the operation of the microprocessor 100 of FIG. 1 in which task switching between multiple encryption routines is implemented using the flag register 128 shown in FIG. 21 in accordance with the teachings of the present invention. The flow then enters block 2202 .

At block 2202, a request is sent to the system software to execute a new encryption procedure. Flow then enters decision block 2204.

At decision block 2204, the system software determines whether there is room in the key register file 124 for a new encryption program. In one embodiment, the request generated by block 2202 may indicate how much space within the key register file 124 is required. If there is room in the key register file 124 for the new encryption program, the process enters block 2208 , otherwise, the process enters block 2206 .

At block 2206, the system software waits for one or more encryption procedures to complete, freeing the key register file 124 for new encryption procedures. The flow then goes to block 2208 .

At block 2208 , the system software allocates space in the key register file 124 to the new encryption program and then fills in the index field 2104 in the flag register 128 to identify the newly allocated space in the key register file 124 . The flow then enters block 2212.

At block 2212 , the system software loads the key value for use by the new program at the key register file 124 location configured at block 2208 . As discussed above, the loaded key value can be loaded from the secure storage area 122 using the key download command 500 , or, if necessary, can be retrieved from a location external to the microprocessor 100 via a secure channel. The process then proceeds to block 2214.

At block 2214, the system software loads the key from the key register file 124 into the master key register 142 based on the key register file index field 604/904/1304. In one embodiment, the system software executes a key switching instruction 600 to load the key into the master key register 142 . The process then proceeds to block 2216.

At block 2216, since control is transferred to the encrypted program, the microprocessor 100 sets the E bit field 402 of the flag register 128 to indicate that the currently executing program is encrypted, and sets the E bit 148 of the control register 144 to set Extraction unit 104 is in decryption mode. Flow ends at block 2216.

Referring now to FIG. 23, a flow diagram illustrates the operation of the microprocessor 100 of FIG. 1 in which the flag register 128 shown in FIG. 21 is employed to handle task switching between multiple encryption programs in accordance with the teachings of the present invention. Flow begins at block 2302.

At block 2302, the currently executing program performs a return operation, returning from an interrupt instruction, causing a task switch to a new program; the new program was previously executed but skipped, and its structural state (e.g., flag register 128, instruction pointer register, and general purpose register) were stored in the stacked memory. As mentioned previously, in one embodiment, the operation of returning from the interrupt instruction is implemented by microcode. The currently executing program and the new program can be encrypted programs or plain text programs. The flow goes to block 2304.

In block 2304, the microprocessor 100 restores the flag register 128 according to the stacked memory to cope with the subsequent return of the program. That is to say, the microprocessor 100 reloads into the flag register 128 the value of the flag register 128 stored in the stack memory when the continuation program (that is, the program currently jumped back to) was previously jumped out. Flow then proceeds to decision block 2306.

At decision block 2306, the microprocessor 100 determines whether the E bit 402 of the repaired flags register 128 is set. If yes, the process enters into block 2308; otherwise, the process enters into block 2312.

At block 2308 , the microprocessor 100 loads the key into the key register file 124 according to the value of the index field 2104 of the EFLAGS register 128 repaired at block 2304 . The process then proceeds to block 2312 .

At block 2312 , the microprocessor 100 updates the contents of the E bit 148 of the control register 144 with the value of the E bit field 402 of the flags register 128 repaired at block 2304 . Therefore, if the following program is an encrypted program, the extracting unit 104 will be set to the decryption mode, otherwise, it will be set to the plain text mode. The process then proceeds to block 2314.

At block 2314, the microprocessor 100 restores the instruction pointer register with the contents of the stack memory and branches to the location pointed to by the instruction pointer, which action will clear the microprocessor 100 of all x86 instructions and clear all micro-operations. What is cleared includes all instruction bytes 106 extracted from the instruction cache memory 102 and buffered and temporarily stored in the fetching unit 104 and the decoding unit 108 waiting to be decrypted and decoded. The process then proceeds to block 2316.

At block 2316, the fetch unit 104 resumes fetching instructions 106 from the continuation program with reference to the techniques of FIGS. Flow ends at block 2316.

Referring now to FIG. 24, a block diagram illustrates another embodiment of a single register of the key register file 124 of FIG. 1, in accordance with the present invention. According to the embodiment shown in FIG. 24 , each key register file 124 also includes one bit—a kill bit 2402 (kill bit, hereinafter referred to as K bit). The K bit 2402 is used to cope with the multitasking operation of the microprocessor 100 on multiple encryption programs that require more key storage space than the size of the key register file 124 in total, as will be described in detail below Of.

Referring now to FIG. 25, a flowchart illustrates the operation of the microprocessor 100 of FIG. 1 in which task switching between multiple encryption programs is implemented in accordance with the teachings of the present invention with the flag register 128 of FIG. 21 and the key register file 124 of FIG. Another implementation of . The flow shown in FIG. 25 is similar to the flow shown in FIG. 22 . The difference is that when the decision block 2204 determines that there is not enough space available in the key register file 124 , the flow of FIG. 25 will enter block 2506 instead of block 2204 in FIG. 25 . In addition, if the decision block 2204 determines that there is still enough free space in the key register file 124, the process in FIG. 25 also enters blocks 2208 to 2216 in FIG. 22 .

In block 2506, the system software configures the space (i.e., the register) that has been used (i.e. has been configured) by other encryption programs in the key register file 124, and sets the K bit 2402 of the configured register to a set state, and The index field 2104 of the flag register 128 is then set to indicate the location of the new configuration space in the key register file 124 . The setting state of the K bit 2402 indicates that the key values related to other encryption programs in the register will be overwritten with the key values of the new encryption program by the operation of block 2212 . However, as described below in FIG. 26, the key values of other encryption programs will be reloaded by block 2609 in their return routines. The process in FIG. 25 enters block 2506 , and then leads to block 2212 shown in FIG. 22 , and ends in block 2216 .

Referring now to FIG. 26 , a flowchart illustrates the operation of the microprocessor 100 of FIG. 1 in which task switching between multiple encryption programs is implemented with the flag register 128 of FIG. 21 and the key register file 124 of FIG. 24 in accordance with the teachings of the present invention. Another implementation of . The flow shown in FIG. 26 is similar to the flow shown in FIG. 23 . The difference is that if the decision block 2306 determines that the E bit 402 of the flag register 128 is set, FIG. 26 makes the process enter the decision block 2607 instead of the block 2308 .

At decision block 2607, the microprocessor 100 determines whether the K bit 2402 of any register in the key register file 124 indicated by the value of the flags register 128 index field 2104 (repaired in block 2304) is set. If yes, the process goes to block 2609; if not, the process goes to block 2308.

At block 2609, the microprocessor 100 generates an exception and sends it to an exception handler for processing. In one embodiment, the exception handling program is designed in the system software. In one embodiment, exception handlers are provided by the Safe Execution Mode framework. According to the value of the index field 2104 of the flag register 128 repaired by the block 2304, the exception handler reloads the key of the currently repaired encryption program (ie, the encryption program returned for execution) into the key register file 124. The exception handler can act similarly to block 1908 previously mentioned in FIG. into the secure storage area 122. Similarly, if the reloaded register in the key register file 124 is used by other encryption programs, the system software will set the K bit 2402 of the register to a set state. The process then enters 2308 from block 2609, and blocks 2308 to 2316 refer to the contents of FIG. 23 .

As taught in FIGS. 24-26 , the embodiments described herein allow the microprocessor 100 to multitask with multiple encryption programs even though the encryption programs require more aggregate key scratchpad space than key register 124 space. size.

Referring now to FIG. 27, a block diagram illustrates another embodiment of the present invention modified from the microprocessor 100 of FIG. Components similar to those in FIG. 1 are numbered the same; for example, instruction cache 102 , fetch unit 104 , and key register file 124 . However, here the extraction unit 104 is modified to further include a key switching logic 2712 coupled to the master key register file 142 and the key register file 124 introduced in FIG. 1 . The microprocessor 100 of FIG. 27 also includes a branch target address cache (branch target address cache, BTAC) 2702. The BTAC 2702 receives the fetch address 134 disclosed in FIG. 1 and parallelizes the access to the instruction cache 102 based on the fetch address 134. According to the extraction address 134, the BTAC 2702 supplies the branch target address 2706 to the extraction address generator 164 disclosed in FIG. logic 2712 and supply a key register file (KRF) index 2716 to the key register file 124.

Referring now to FIG. 28, a block diagram illustrates the BTAC 2702 of FIG. 27 in greater detail in accordance with the teachings of the present invention. BTAC 2702 includes a BTAC matrix 2802 having a plurality of BTAC units 2808 therein, and FIG. 29 illustrates the contents of BTAC units 2808. The information stored in the BTAC 2802 includes historical information of previously executed branch instructions to predict the direction and target address of the next executed branch instructions. In particular, the BTAC 2802 uses stored history information to predict subsequent fetch operations for previously executed branch instructions based on the fetched address 134 . The operation of the branch target address cache can refer to common branch prediction techniques. However, the BTAC 2802 disclosed in the present invention is further modified to record the history information of the previously executed branch and switch key instructions 900/1200, so as to perform related predictive operations. In particular, the stored history allows the BTAC 2802 to predict, at fetch time, the set of values that the fetched branch and switch key instruction 900/1200 will load into the master key register 142. This operation enables the key switch logic 2712 to load the key value before the branch and switch key instruction 900/1200 is actually executed, avoiding being limited by the need to flush the microprocessor upon execution of the branch and switch key instruction 900/1200 The pipeline content of 100 will be discussed in detail below. In addition, according to one embodiment, the BTAC 2802 is further modified to store history information including previously executed key switching instructions 600, so as to achieve the same effect.

Referring now to FIG. 29, a block diagram illustrates in more detail the contents of the BTAC unit 2808 of FIG. 28 in accordance with the teachings of the present invention. Each cell 2808 includes a valid bit 2902 indicating whether the associated cell 2808 is valid. Each cell 2808 also includes a tag field 2904 for comparison with the portion of the extracted address 134 . If the unit 2808 selected by the index part of the fetch address 134 makes the tag part of the fetch address 134 coincide with the valid tag 2904, then the fetch address 134 hits the BTAC 2802. Each array unit 2808 also includes a target address field 2906 for storing target addresses of previously executed branch instructions, including branch and switch key instructions 900/1200. Each array unit 2808 also includes a take/not take field 2908 for storing direction (take/not take) records of previously executed branch instructions, including branch and switch key instructions 900/1200. Each array unit 2808 also includes a key register index field 2912 for storing key register file index 904/1304 records of previously executed branch and switch key instructions 900/1200, discussed in detail below. According to one embodiment, the BTAC 2802 stores the key register file index 604 record of the previously executed key switching instruction 600 in its key register file index field 2912. Each array element 2808 also includes a type field 2914 indicating the type of instruction recorded. For example, the type field 2914 can indicate that the recorded historical instruction is a call (call), return (return), conditional jump (conditional jump), unconditional jump (unconditional jump), branch and switch key instruction 900/1200, or password key switching instruction 600.

Referring now to FIG. 30, a flowchart illustrates the operation of the microprocessor 100 of FIG. 27, which includes the BTAC 2802 disclosed in FIG. 28, in accordance with the present techniques. Flow begins at block 3002.

At block 3002, the microprocessor 100 executes a branch and switch key instruction 900/1200, which will be described in detail with reference to FIG. 32 below. The flow then enters block 3004 .

In block 3004, the microprocessor 100 configures an array unit 2808 in the BTAC 2802 for the executed branch and switch key instruction 900/1200, and the direction, target address, The key register file index 904/1304 and the instruction type are respectively recorded in the adopted/not used field 2908, the target address field 2906, the key register file index field 2912, and the type field 2914 of the configured array unit 2808, to As the history information of the branch and switch key instruction 900/1200. The process ends at block 3004.

Referring now to FIG. 31, a flowchart illustrates the operation of the microprocessor 100 of FIG. 27, which includes the BTAC 2802 disclosed in FIG. 28, in accordance with the present techniques. Flow begins at block 3102.

At block 3102 , the fetch address 134 is supplied to the instruction cache 102 and the BTCA 2802 . The process then proceeds to block 3104 .

In block 3104, the extraction address 134 is centered on the BTAC 2802, and the BTAC 2802 converts the contents of the target address 2906, adopt/not adopt 2908, key register file index 2912 and type 2914 fields of the corresponding array unit 2808 to the target address 2706, adopt /Do not take the pointer 2708 , key register document index 2712 , and type pointer 2714 outputs. In particular, the type field 2914 is used to indicate that the stored instruction is a branch and switch key instruction 900/1200. Flow then proceeds to decision block 3106.

At decision block 3106, the key switch logic 2712 determines that the branch and switch key instruction 900/1200 is predicted to be taken by the BTAC 2802 by checking the take/not take output 2708. If the take/not take output 2708 shows that the branch and switch key instruction 900/1200 is predicted to be taken, then the flow proceeds to block 3112 ; otherwise, the flow proceeds to block 3108 .

At block 3108, the microprocessor 100 sends an indication along with the branch and switch key instruction 900/1200, indicating that the BTAC 2802 predicts that it will not be taken. (Additionally, if the take/not take output 2708 indicates that the branch and switch key instruction is predicted to be taken, the microprocessor 100 sends an indication along with the branch and switch key instruction 900/1200 at block 3112, showing BTAC 2802 predicts its adoption). Process ended at 3108

At block 3112, the fetch address generator 164 updates the fetch address 134 with the target address 2706 predicted by the BTAC 2802 at block 3104. The process then proceeds to block 3114.

At block 3114, based on the key register file index 2712 predicted by the BTAC 2802 at block 3104, the key switch logic 2712 updates the key value in the master key register 142 with its indicated key register file 124 location. In one embodiment, if necessary, the key switching logic 2712 delays the fetching unit 104 from fetching blocks in the instruction data 106 until the master key register 142 is updated. Flow then proceeds to block 3116.

At block 3116 , the fetch unit 104 continues to fetch and decrypt the instruction data 106 using the new master key register 142 contents loaded at block 3114 . Flow ends at block 3116.

Referring now to FIG. 32, a flow diagram illustrates the operation of the microprocessor 100 of FIG. 27 in which a branch and switch key instruction 900/1200 is executed in accordance with the teachings of the present invention. The flow chart of FIG. 32 is similar to the flow chart of FIG. 10 in some respects, and similar blocks are given the same reference numerals. Although the discussion of FIG. 32 refers to the content of FIG. 10 , its application can take into consideration the operation of the branch and switch key instruction 1200 introduced in FIG. 14 . The FIG. 32 process begins at block 1002 .

In block 1002, the decoding unit 108 decodes a branch and switch key instruction 900/1200, and substitutes it into the microcode unit 132 to implement the microcode program of the branch and switch key instruction 900/1200. The flow then enters block 1006 .

At block 1006, the microcode resolves the branch direction (ie, taken/not taken) and the target address. The process then proceeds to block 3208 .

At block 3208, the microcode determines whether the BTAC 2802 provides a prediction for the branch and switch key instruction 900/1200. If provided, the process proceeds to decision block 3214 ; if not provided, the process proceeds to block 1008 of FIG. 10 .

In the decision block 3214, the microcode judges whether the prediction made by the BTAC 2802 is correct or not by taking the take/not take indicator 2708 and the target address 2706 sent by the BTAC 2802 and the direction and target address solved in block 1006. If the prediction of BTAC 2802 is correct, the process ends; otherwise, the process comes to decision block 3216.

At decision block 3216, the microcode determines whether the incorrect BTAC 2802 prediction was taken. If adopted, the process enters block 3222; if not, the process enters block 1014 in FIG. 10 .

At block 3222, the microcode repairs the contents of the master key register 142 because the wrong prediction made by the BTAC 2802 for the branch and switch key instruction 900/1200 was taken, causing block 3104 of Figure 31 to load it with the wrong key value . In one embodiment, the key switching logic 2712 includes the storage elements and logic needed to repair the master key register 142 . In one embodiment, the microcode generates an exception alert for an exception handler to repair the master key register 142 . In addition, the microcode causes the microprocessor 100 to branch and jump to the x86 instruction following the branch and switch key instruction 900/1200 such that all x86 instructions in the microprocessor 100 newer than the branch and switch key instruction 900/1200 Clear, and clear all microcodes in the microprocessor 100 that are newer than the microcode that branches to the target address. The content to be emptied includes all instruction bytes 106 read from the instruction cache 102 and buffered and temporarily stored in the fetch unit 104 and the decode unit 108 waiting to be decoded. Following the branch to the subsequent instruction, the fetch unit 104 begins fetching and decrypting the instruction data 106 from the instruction cache 102 using the set of repaired key values in the master key register 142 . Flow ends at block 3222.

In addition to the above-mentioned security advantages brought by the implementation of instruction decryption implemented by the microprocessor 100, the inventors have developed a suggested coding guideline, which can be used in combination with the above implementation methods to weaken the problem by analyzing the actual usage of x86 instructions, A hack developed with statistical techniques on encrypted x86 codes.

First, since hackers usually assume that the extracted 16-byte instruction data 106 are all x86 instructions, relative to the program execution flow, "holes" should be added between 16-byte blocks during encoding. That is, its encoding should skip some instruction bytes with multiple instructions, and create multiple "holes" with unencrypted bytes, which can be filled with appropriate values to increase the entropy of plain text bytes . In addition, if the entropy value of plain text bytes can be further improved, its encoding can use real-time data values as much as possible. Additionally, the immediate data value can serve as a false clue pointing to the wrong instruction opcode address.

Second, the encoding may include special NOP instructions including a "ignore" field filled with appropriate values to increase the entropy value mentioned above. For example, the x86 instruction 0x0F0D05xxxxxxxx is a 7-byte NOP, where the last four bytes can be any value. In addition, the opcode type of the NOP instruction and the number of "don't care" bytes may have other variations.

Third, many x86 instructions have the same basic functionality as other x86 instructions. For instructions with equivalent functions, the code can abandon the repeated use of the same instruction, and instead adopt a multi-type format and/or adopt a type that increases the entropy value of the plain text. For example, instruction 0xC10107 and instruction 0xC10025 do the same thing. Furthermore, some equivalent instructions are presented in different length versions, for example, 0xEB22 and 0xE90022; therefore, instructions of various lengths but with the same effect can be used when encoding.

Fourth, the x86 architecture allows the use of redundant and meaningless opcode prefixes, which can be carefully applied when encoding to increase the entropy value mentioned above. For example, instructions 0x40 and 0x2627646567F2F340 do exactly the same thing. Since there are only 8 safe x86 prefixes, they need to be carefully inserted into the code to avoid appearing too frequently.

While various embodiments have been described in which a key expander rotates and adds/subtracts a pair of values in a master key register value, other implementations are contemplated in which the key expander operates on more than Operations are performed on the values of the two master key registers, and in addition, the operations performed may be different from rotation and addition/subtraction operations. In addition, the key switch instruction 600 disclosed in FIG. 6 and the branch and switch key instruction 900 disclosed in FIG. 9 can also have other implementations, for example, the new key value is loaded from the secure storage area 122 into the master key register 142 Rather than being loaded by the key register file 124 , another implementation of the branch and switch key instruction 1500 described in FIG. 15 is to store the address of the secure storage area 122 in the index field 2104 . In addition, although various embodiments have been listed to adjust the BTAC 2702 to store the KRF index in conjunction with the branch and switch key instructions 900/1200, there are other implementations that adjust the BTAC 2702 to store the secure storage area address to combine the branch and switch key instructions 1500 used.

The embodiments of the present invention listed above are only used as illustrative examples, and are not intended to limit the scope of the invention. Numerous changes in form and details may be made by persons skilled in the relevant computer arts without departing from the scope of the present invention. For example, the means of functioning, making, modularizing, simulating, illustrating, and/or testing the devices and methods discussed herein can be implemented in software. The implementation includes general programming languages (for example, C, C++), hardware description languages including Verilog HDL, VHDL, etc., or other available programming tools. The software can be carried on any known computer-readable medium, such as magnetic tape, semiconductor, magnetic disk, or optical disk (eg, CD-ROM, DVD-ROM, etc.), network, wired transmission, wireless or other communication media. Implementations of the described apparatus and methods may be included in a semiconductor intellectual property core, such as a microprocessor core (eg, implemented in HDL), and may be converted to hardware for implementation in an integrated circuit. In addition, the devices and methods described above can be implemented in a combination of software and hardware. Therefore, the scope of the present invention should not be limited to any of the above embodiments, but should be defined by the claims of the present invention and their equivalent techniques. In particular, the inventive technique may be implemented with microprocessors employed in general purpose computers. It is worth noting that those skilled in the art may design or modify other structures based on the disclosed concepts and specific embodiments without departing from the scope of the invention defined by the claims to produce the same effect as the present invention.

Claims (114)

1. A microprocessor comprising: an instruction cache memory; an instruction decoding unit; and An extraction unit for: (a) fetching a block of instruction data from the instruction cache; (b) performing a Boolean XOR operation on the block with a data entity to generate plain text instruction data; and (c) supplying the above-mentioned plain text instruction data to the instruction decoding unit; Wherein, in a first situation, the block includes encrypted instruction data, and the data entity is a decryption key; Wherein, in a second condition, the block includes non-encrypted instruction data, and the data entity is a binary zero value of multiple bits; Wherein, no matter whether the command data of the block is encrypted or unencrypted, the time required to execute the above-mentioned contents (a), (b) and (c) in the above-mentioned first situation and the second situation is the same. 2. The microprocessor as claimed in claim 1, wherein the fetch unit applies a fetch address to the instruction cache to fetch the instruction data of the block from the instruction cache, wherein, from the instruction When the cache memory fetches the instruction data of the block, the fetching unit also uses part of the fetching address and a plurality of key values to form a function to generate the decryption key. 3. The microprocessor as claimed in claim 2, wherein, in order to generate the decryption key as a function of the extraction address and the above-mentioned multiple key values, the extraction unit is also used for: selecting a pair of the plurality of key values based on a first part of the extraction address; rotating the selected one of the pair of key values based on a second portion of the extraction address; and Based on a third portion of the extraction address, the rotated key value is added to or subtracted from the selected another key value to generate The decryption key. 4. The microprocessor as claimed in claim 2, wherein, in order to generate the decryption key as a function of the extraction address and the above-mentioned plurality of key values, the extraction unit is also used for: selecting a first key value from the plurality of key values according to a first part of the extraction address; selecting a second key value from the plurality of key values according to the first part of the extraction address; rotating the first key value based on a second portion of the extraction address; and Selecting to add the rotated first key value to the second key value or to subtract the rotated first key value from the second key value according to a third part of the extraction address, to generate the decryption key. 5. The microprocessor as claimed in claim 2, wherein the total amount of the above-mentioned multiple key values is K, the decryption key and the respective lengths of the above-mentioned multiple key values are W bytes, and the extraction unit generating a sequence of multiple decryption keys for a sequence of multiple blocks of command data extracted from the command cache, wherein W ² *(K!/( 2*(K-2)!)) different combinations to decrypt the extracted sequence of blocks. 6. The microprocessor as claimed in claim 1, wherein the extracting unit comprises: A control bit is used to store a flag indicating that the extraction unit is in a decryption mode or a plain text mode; a multiplexer, comprising: an output; a first data input for receiving the decryption key; a second data input for receiving the binary zero value of the plurality of bits; and a selection control input for receiving the value of the control bit, in the first case, when the value of the control bit corresponds to the decryption mode, the decryption key is used as the output, and, in the second case, When the value of the control bit corresponds to the plain text mode, the binary zero value of the above-mentioned bits is used as the output; and A different logic, including: a first data input for receiving the output of the multiplexer; a second data input for receiving the fetched instruction data of the block; and An output, coupled to the instruction decoding unit, supplying the pure text instruction data obtained by performing Boolean XOR operation on the first and second data inputs of the different gate. 7. The microprocessor of claim 6, wherein the first data input to the multiplexer is from: a first multiplexer for selecting a first key value from a plurality of key values according to a first part of an extraction address; a second multiplexer, selecting a second key value from the plurality of key values according to the first part of the extraction address; a rotator that rotates the first key value based on a second portion of the extraction address; and An operation unit, according to a third part of the extraction address, choose to add the rotated first key value to the second key value, or add the rotated first key value from the second key value The value is subtracted to generate the decryption key. 8. An operating method for operating a microprocessor having an instruction cache memory, the operating method comprising: (a) fetching a block of instruction data from the instruction cache; (b) performing a Boolean XOR operation on the block with a data entity to generate plain text instruction data; and (c) supplying the above-mentioned plain text instruction data to an instruction decoding unit; Wherein, in a first situation, the block includes encrypted instruction data, and the data entity is a decryption key; Wherein, in a second condition, the block includes non-encrypted instruction data, and the data entity is a binary zero value of multiple bits; Wherein, no matter whether the command data of the block is encrypted or unencrypted, the time required to execute the above-mentioned contents (a), (b) and (c) in the above-mentioned first situation and the second situation is the same. 9. The operation method as claimed in claim 8, wherein the step of extracting the block from the instruction cache comprises applying an extraction address to the instruction cache, the operation method further comprising: generating the decryption key with a function formed by part of the extraction address and a plurality of key values; Wherein, the generation of the decryption key is performed during the period of fetching the command data of the block from the command cache. 10. The operation method according to claim 9, wherein the step of generating the decryption key as a function of the extraction address and the above-mentioned multiple key values comprises: selecting a pair of the plurality of key values based on a first part of the extraction address; rotating one of the selected pair of key values based on a second portion of the extraction address; adding the rotated key value to or subtracting the rotated key value from the selected another key value based on a third portion of the extraction address, to generate the decryption key. 11. The operation method as claimed in claim 9, wherein the step of generating the decryption key using the function formed by the extraction address and the plurality of key values is to generate ^W2 for instruction data of a plurality of consecutive blocks The effective decryption key length of *(K!/(2*(K-2)!)) bytes, wherein, the length of the decryption key and the above-mentioned multiple key values is W bytes, and the above-mentioned multiple The total number of key values is K. 12. A microprocessor comprising: an instruction cache memory; A fetching unit extracts an encrypted instruction having a sequence of multiple blocks in an encryption program from the instruction cache according to a sequence of multiple fetching address values, wherein, when fetching each block of the sequence, the fetching unit further uses A plurality of key values in the extraction unit and part of the extraction address value of the extracted block are a function to generate a decryption key to decrypt the encrypted instruction of the extracted block; and A key switching instruction, when the fetching unit fetches the sequence of the plurality of blocks from the instruction cache memory, instructs the microprocessor to update the values of the plurality of keys in the fetching unit. 13. The microprocessor as claimed in claim 12, wherein the extraction unit inherently supplies an effective decryption key length for decrypting the encrypted program, wherein the effective decryption key length depends on the sum of the values of the plurality of keys amount, and the manner in which the extraction unit generates the above-mentioned decryption key, wherein the operation of updating the above-mentioned multiple key values in the extraction unit with the key switching instruction in the encryption program will extend the effective decryption key length, Make it beyond the length of innate supply. 14. The microprocessor of claim 13, wherein the extended effective decryption key length is as long as the encryption program. 15. The microprocessor of claim 12, further comprising: A register file, storing multiple sets of key values; Wherein, the above-mentioned key switching instruction marks an index value indicating the position of one of the above-mentioned multiple sets of key values in the register file, and the microprocessor will use the index value marked by the key switching instruction, and the The set of key values indicated by the index value updates the plurality of key values used to generate the decryption key in the extracting unit. 16. The microprocessor of claim 12, wherein the microprocessor comprises a pipeline comprising: an execution unit is located after the fetch unit; Wherein, the extraction unit extracts and decrypts a first and a second encrypted instruction of the encrypted program to obtain a first and a second non-encrypted instruction; Wherein, if the key switching instruction is executed, the execution unit replaces a first decryption key used to decrypt the first encrypted instruction with a second decryption key, wherein the second decryption key is used to decrypt the second encrypted instruction. 17. The microprocessor of claim 16, wherein the microprocessor further clears a pipeline instruction of a first non-encrypted instruction newer than the key switch instruction in program order. 18. The microprocessor of claim 12, further comprising: The microcode is used to implement the key switching instruction. 19. The microprocessor of claim 12, wherein the microprocessor further jumps to a subsequent instruction following the key switching instruction in program order in response to execution of the key switching instruction. 20. A method of operating a microprocessor having an instruction cache, the method of operating comprising: extracting a plurality of first encrypted instructions in a program from the instruction cache memory, and decrypting them into a plurality of first non-encrypted instructions with a first decryption key; replacing the first decryption key with a second decryption key in response to execution of a key switch command among the plurality of first non-encryption commands; and A plurality of second encrypted instructions of the program are fetched from the instruction cache memory, and decrypted into a plurality of second non-encrypted instructions with the second decryption key. 21. The operation method as claimed in claim 20, wherein the key switching instruction marks an index value to indicate a position of a register file in the microprocessor, wherein the first decryption key is set in the The second decryption key replacing step includes loading the second decryption key into a fetch unit of the microprocessor from the location of the register file indicated by the index value. 22. The operating method according to claim 20, wherein the step of extracting the second encrypted instructions comprises jumping to the instruction following the key switch instruction in the program sequence. 23. The operating method as claimed in claim 20, wherein the program comprises a first block of continuous instructions followed by a second block of continuous instructions, wherein the first block of continuous instructions includes the first encryption instructions , and the second block of continuous instructions includes the second encrypted instructions, wherein the first block of continuous instructions is encrypted with the first decryption key, and the second block of continuous instructions is encrypted with the second decryption key, Wherein, the key switching instruction is the last instruction of the first block of continuous instructions. 24. An operating method for operating a microprocessor, the operating method comprising: fetching a sequence of encryption instructions of a plurality of blocks in an encryption program from a sequence of a plurality of fetch addresses of an instruction cache; When extracting each block of the sequence, a decryption key is generated by using a plurality of key values and partial values of the extraction address of the extracted block as a function; For each block extracted in the sequence, decrypt the encrypted instruction therein with the above-mentioned correspondingly generated decryption key; and Executing the key switching instruction between the blocks of the sequence, wherein the step of executing the key switching instruction includes updating the key values used to generate the decryption key. 25. The operation method as claimed in claim 24, wherein the key switching instruction is a decrypted instruction obtained by decrypting the encrypted instruction of one of the extracted blocks of the sequence. 26. The operation method as claimed in claim 24, wherein, the function formed by the key values and the corresponding partial values of the extraction address inherently provides an effective decryption key length for decrypting the encrypted program, wherein, The inherent size of the effective decryption key length depends on the total amount of these key values and the above-mentioned decryption key generation operation method, wherein updating these key values in the above-mentioned key switching command will extend the effective decryption key length beyond Innate size. 27. The operating method as claimed in claim 26, wherein the length of the extended effective decryption key is equal to the length of the encryption program. 28. The operation method as claimed in claim 24, wherein the key switching command marks an index value indicating a location in the microprocessor for storing the key values for performing the updating step. 29. A microprocessor comprising: an extraction unit extracts and decrypts a branch and switch key instruction using the first decryption key data; and Microcode for: Under the condition that the direction of the branch and switch key instruction is not adopted, the extracting unit extracts and decrypts the continuation instruction after the branch and switch key instruction with the above-mentioned first decryption key data; and causing the extraction unit to extract and decrypt an object of the branch and switch key instruction with second decryption key data different from the first decryption key data in the case where the direction of the branch and switch key instruction is adopted instruction. 30. The microprocessor of claim 29, wherein if the direction of the branch and switch key instruction is taken, said microcode further before causing said fetch unit to decrypt said target instruction with said second decryption key data , updating the extracting unit so that the extracting unit uses the second decryption key data instead of the first decryption key data. 31. The microprocessor of claim 29, wherein if the direction of the branch and switch key instruction is adopted, the branch and switch key instruction indicates the storage of the second decryption key data in the microprocessor The location for this extraction unit to load. 32. The microprocessor of claim 29 , wherein if the direction of the branch and switch key instruction is adopted, the microcode further determines that the second decryption key data is stored in the microcode based on the memory address of the target instruction. A storage location within the processor for the fetch unit to load. 33. The microprocessor as claimed in claim 32, wherein, in order to judge the storage location of the second decryption key data in the microprocessor according to the memory address of the target instruction, the microcode queries the memory address A table in the microprocessor records a mapping of memory address ranges to storage locations in the microprocessor. 34. The microprocessor of claim 33, wherein the storage location of the microprocessor is programmed in a register or a random access memory of the microprocessor. 35. The microprocessor of claim 29, wherein the microprocessor executes the branch and switch key instruction atomically. 36. The microprocessor of claim 29, wherein the extraction unit is also used for: Before decrypting the branch and switch key instruction, a decryption key is generated based on the first decryption key data and part of an extraction address for extracting the branch and switch key instruction; Wherein, in order to decrypt the branch and switch key instruction using the first decryption key data, the extracting unit performs a Boolean XOR operation on the branch and switch key instruction with the generated decryption key. 37. An operation method, processing an encryption program with a microprocessor, the operation method comprising: extracting and decrypting a branch and switch key instruction using the first decryption key data; If the direction of the branch and switch key instruction is not adopted, extracting and decrypting a continuation instruction after the branch and switch key instruction based on the first decryption key data; and If the direction of the branch and switch key instruction is adopted, a target instruction of the branch and switch key instruction is extracted and decrypted based on the second decryption key data different from the first decryption key data. 38. The operation method as claimed in claim 37, wherein the above-mentioned operation of decrypting the branch and switching key instruction and the continuation instruction based on the above-mentioned first decryption key data is performed by using the first decryption key in the microprocessor An extraction unit of data is executed, wherein, if the direction of the branch and switch key instruction is adopted, the operation method further includes: Before decrypting the target instruction based on the second decryption key data, the extraction unit is updated to use the second decryption key data instead of the first decryption key data. 39. The operating method as claimed in claim 37, wherein, if the direction of the branch and switch key instruction is adopted, the branch and switch key instruction indicates a storage of the second decryption key data in the microprocessor The location for this extraction unit to load. 40. The operation method according to claim 37, if the direction of the branch and switch key instruction is adopted, further comprising: A storage location of the above-mentioned second decryption key data in the microprocessor is determined according to the memory address of the target instruction, so as to be loaded by the extracting unit. 41. The operation method according to claim 40, wherein the step of judging the storage location of the second decryption key data in the microprocessor according to the memory address of the target instruction comprises querying the microprocessor based on the memory address A table within the processor that records a mapping of memory address ranges to storage locations of the microprocessor. 42. The operating method of claim 41, wherein the storage location of the microprocessor is located in a register or a random access memory of the microprocessor. 43. The operating method as claimed in claim 37, wherein the execution of the branch and switch key instruction is performed atomically by the microprocessor. 44. The method of operation of claim 37, further comprising: Before the step of decrypting the branch and switch key instruction, generate a decryption key according to the first decryption key data and part of an extraction address for extracting the branch and switch key instruction; Wherein, the step of decrypting the branch and switch key instruction based on the first decryption key data includes performing a Boolean XOR operation on the branch and switch key instruction with the generated decryption key. 45. An encryption method for encrypting a program for later execution by a microprocessor for decrypting and executing the encrypted program, the encryption method comprising: receiving an object file for an unencrypted program, the unencrypted program including legacy branch instructions whose target addresses are determined before the microprocessor executes the program; analyzing the program to obtain block information, the block information dividing the program into a sequence of multiple blocks, wherein each of the above blocks includes a sequence of multiple instructions, wherein the block information also includes encryption key data for each of the above blocks, wherein , the encryption key data of each block is not the same; Replacing the target addresses of the above traditional branch instructions that are not located in the same block as themselves with a branch and switch key instruction; and The program is encrypted based on the above block information. 46. The encryption method according to claim 45, wherein each of the above-mentioned branch and switch key instructions marks a storage space in the microprocessor to store the encryption key of the block where the target address of the above-mentioned branch and switch key instructions is located. key data. 47. The encryption method as claimed in claim 45, wherein said step of encrypting the program according to the block information comprises: For the instruction data of each block in each block, an encryption key is generated based on the encryption key data of the block and a part of a memory address of the block; and Perform a Boolean XOR operation on the corresponding block with the generated encryption key. 48. An encryption method for encrypting a program for later execution by a microprocessor for decrypting and executing the encrypted program, the encryption method comprising: receiving an object file of an unencrypted program, the unencrypted program including conventional branch instructions whose target addresses can only be determined when the microprocessor executes the program; analyzing the program to obtain block information, the block information dividing the program into a sequence of multiple blocks, wherein each of the above blocks includes a sequence of multiple instructions, wherein the block information also includes encryption key data for each of the above blocks, wherein , the encryption key data of each block is not the same; replacing each of the above conventional branch instructions with a branch and switch key instruction; and Based on the above block information, the program is encrypted. 49. The encryption method of claim 48, further comprising: The above-mentioned block information is incorporated into the object file, so as to be loaded into the microprocessor before the microprocessor executes the program. 50. The encryption method as claimed in claim 49, wherein, the above-mentioned block information loaded in the target file and loaded into the microprocessor before executing the program indicates a storage space in the microprocessor for each of the above-mentioned blocks , to store the above-mentioned encryption key data about each of the above-mentioned blocks. 51. The encryption method as claimed in claim 48, wherein said step of encrypting the program based on block information comprises: For the instruction data of each block of each of the above blocks, an encryption key is generated based on the encryption key data of the block and a part of a memory address of the block; and With the above generated encryption key, perform Boolean XOR operation on the corresponding block. 52. A microprocessor comprising: a register having one bit, wherein the microprocessor is used to set the bit; and a fetch unit for fetching encrypted instructions from an instruction cache and decrypting said encrypted instructions before executing said encrypted instructions in response to the microprocessor setting the bit; Wherein, the microprocessor stores the value of the bit to a memory, and then clears the bit in response to receiving an interrupt event; Wherein, after the microprocessor clears the bit, the extraction unit extracts the non-encrypted instruction from the instruction cache, and executes the above-mentioned non-encrypted instruction without decrypting it; Wherein, the microprocessor uses the previously stored value from the memory to repair the bit of the register in response to the return operation from the interrupt instruction; Wherein, if it is determined that the value of the bit after repair is set, the extracting unit will start extracting and decrypting the encrypted instruction again. 53. The microprocessor of claim 52, wherein the bit of the register is a reserved bit of the x86 architecture flags register. 54. The microprocessor of claim 52, wherein: If the bit is set, in order to decrypt the encrypted instruction, the extraction unit performs a Boolean XOR operation on the encrypted instruction with a decryption key; and If the bit is cleared, the fetch unit performs a Boolean XOR operation on non-encrypted instructions with multi-bit binary zero values. 55. The microprocessor as claimed in claim 52, wherein the microprocessor is configured to execute a system software to receive a request to execute a first program having encrypted instructions, and, during a second program having encrypted instructions Under the condition of being executed by the microprocessor, the first program is executed after the second program is executed. 56. An operating method for operating a microprocessor having an instruction cache and a register, the operating method comprising: setting a bit of the register, and then fetching the encrypted instruction from the instruction cache, and decrypting the encrypted instruction before executing the encrypted instruction; storing the value of the bit of the architectural register and then clearing the bit in response to receiving an interrupt event; After the bit is cleared, unencrypted instructions are fetched from the instruction cache and executed without decryption; restoring the bit of the register with the previously stored value in response to a return from the interrupt instruction; and If it is determined that the restored value of the bit is the set state, reply to the above operations of extracting, decrypting, and executing the encrypted instruction. 57. The operating method as claimed in claim 56, wherein the bit of the architectural register is a reserved bit of an x86 architectural flag register. 58. The method of operation of claim 56, wherein: If the bit is set, the step of decrypting the encrypted instruction includes performing a Boolean XOR operation on the encrypted instruction with a decryption key; and If the bit is cleared, the above-mentioned operation of not decrypting the non-encrypted instruction includes performing a Boolean XOR operation on the non-encrypted instruction with a multi-bit binary zero value. 59. The method of operation of claim 56, further comprising: receiving a request for the purpose of executing a first program with encrypted instructions; and If the microprocessor is executing a second program with encrypted instructions, it waits until the second program is executed before executing the first program. 60. A microprocessor comprising: a register, having one bit; and an extraction unit; Wherein, if receiving a request to interrupt the program in execution, the microprocessor stores the value of the bit, wherein the bit indicates that the program in execution is encrypted or non-encrypted; wherein the microprocessor restores the bit with a previously stored value, and refetches the interrupted program as a running program in response to a return from the interrupt instruction; Wherein, if the value after the repair of the bit is set, the microprocessor restores the decryption key value before re-extracting the interrupted program, and decrypts the extracted instruction with the repaired decryption key value; Wherein, if the repaired value of the bit is cleared, the microprocessor will neither repair the key value nor decrypt the extracted instruction. 61. The microprocessor of claim 60, wherein the bit is a bit of an x86 architecture flags register. 62. The microprocessor of claim 60, wherein the microprocessor stores the value of the bit in a memory, wherein the microprocessor stores a previously stored value from the memory for restoring the bit bit. 63. The microprocessor of claim 60, wherein: to decrypt the fetched instruction with the restored decryption key value, the microprocessor develops a decryption key with the restored decryption key value and performs a Boolean XOR operation on the fetched instruction; and In order not to perform a decryption operation on the fetched instructions, the microprocessor performs a Boolean XOR operation on the fetched instructions with multi-bit binary zero values. 64. The microprocessor of claim 60, wherein, to restore the decryption key value, the microprocessor loads the decryption key value into a register file from a storage element, wherein the storage element stores a plurality of The respective decryption key values of the encrypted programs, wherein the register file stores the decryption key values of the program being executed. 65. The microprocessor as claimed in claim 64, wherein the microprocessor is also used for executing a system software to receive a request to execute a new encryption program, if the storage element does not have enough free space to store the new encryption The decryption key value of the program, wait until the storage element frees up enough free space to execute the above-mentioned new encryption program. 66. A method of operating for operating a microprocessor, the operating method comprising: storing a value of a bit of the microprocessor in response to a request received to interrupt a running program, wherein the bit indicates whether the running program is encrypted or non-encrypted; In response to a return from the interrupt instruction, the previously stored value is used to restore the bit, and the interrupted program is re-fetched to behave as the running program; If the restored value of the bit is set, before re-extracting the interrupted program, restore the decryption key value, so as to use the restored decryption key value to decrypt the extracted instruction; and If the repaired value of the bit is cleared, the decryption key value is not repaired, and the fetched instruction is not decrypted. 67. The method of operation as claimed in claim 66, wherein the step of storing the value of the bit comprises storing the value of the bit to a memory, wherein the step of restoring the bit with the previously stored value comprises storing the value of the bit from the memory The previously stored value is restored to this bit. 68. The method of operation of claim 66, wherein: The step of decrypting the extracted instruction using the restored decryption key value includes performing a Boolean XOR operation on the extracted instruction with a decryption key derived from the restored decryption key value; and The step of undecrypting the fetched instructions includes performing a Boolean XOR operation on the fetched instructions with multi-bit binary zero values. 69. The operation method as claimed in claim 66, wherein the step of restoring the decryption key value comprises loading the decryption key value into a register file from a storage element, wherein the storage element stores the respective The decryption key value, wherein the register file stores the decryption key value of the encryption program being executed. 70. The method of operation of claim 69, further comprising: receiving a request to implement a new encryption procedure; If the storage element does not have enough free space to store the decryption key value of the new encryption program, wait until the storage element has enough free space before executing the new encryption program. 71. A microprocessor comprising: A storage element, including a plurality of locations, used to respectively store decryption key data of an encryption program; A control register including a field indicating a corresponding encryption program in execution for the plurality of locations of the storage element, wherein the microprocessor restores the previously stored value of the field to the control register from the memory in response to the The operation returned by the interrupt instruction; An extracting unit extracts the encryption instruction of the encryption program in execution, and decrypts the decryption key data stored in the position indicated by the storage element with the repaired value of the field. 72. The microprocessor as claimed in claim 71 , wherein, regarding the request for the microprocessor to execute a new encryption program, the microprocessor further sets the field of the control register to indicate that the storage element is allocated to the new encryption program. The location where the encryption program stores the decryption key data. 73. The microprocessor as claimed in claim 72, wherein, the microprocessor further loads the decryption key data of the above-mentioned new encryption program into the corresponding configurator in these locations, and loads the corresponding configurator from these locations. The extraction unit. 74. The microprocessor of claim 71 , wherein the storage element comprises a register file or a memory, wherein each of the plurality of locations of the storage element comprises a register storing decryption key data or a memory location storing decryption key data key data. 75. The microprocessor as claimed in claim 71, wherein the extracting unit further uses the decryption key data stored in the position indicated by the storage element to execute Boolean on the extracted encrypted instruction by using the repaired value of the field. exclusive operation to decrypt the extracted encrypted instructions. 76. The microprocessor of claim 71, wherein the control registers include an x86 architecture flags register that fixes said field. 77. The microprocessor as claimed in claim 71, wherein, in response to the above-mentioned operation returning from the interrupt instruction, if the value after the repair of the field is set at the bit associated with the position indicated by the storage element, the microprocessor The processor issues an exception warning before the fetch unit decrypts the fetched encrypted instruction. 78. The microprocessor as claimed in claim 77, wherein, in response to the abnormal warning, the microprocessor reloads the decryption key data of the encrypted program in execution before the fetch unit decrypts the fetched encrypted instruction The repaired value of the field is at the position indicated by the storage element. 79. The microprocessor as claimed in claim 77, wherein the bit is set to a set state to show that the encrypted program to be restarted is stored on the storage element before the operation of returning from the interrupt instruction is executed. The decryption key data stored in the corresponding location has been overwritten. 80. The microprocessor as claimed in claim 79, wherein the location overwriting condition in the storage element occurs when the microprocessor starts to execute a new encryption program, but the storage element does not have enough free space to store the new encryption program. The encryption program's decryption key data. 81. The microprocessor as claimed in claim 79, wherein the location overwriting condition in the storage element occurs after the microprocessor responds to the abnormal warning and reloads the decryption key data corresponding to the executed program into the field for repair When the value is at the position indicated by the storage element. 82. The microprocessor of claim 71, wherein the microprocessor further executes system software to: Receive requests to implement new encryption procedures; When the free space in the storage element is not enough to store the decryption key data of the new encryption program, wait until the storage element is provided with enough free space before executing the new encryption program. 83. An operating method for operating a microprocessor having a control register and a storage element, and a plurality of locations in the storage element are used to respectively store decryption key data of an encryption program, the above-mentioned operating method comprising: restoring a field of the control register with a value of the field previously stored in the memory in response to an operation returning from an interrupt instruction, wherein the value of the field indicates which of a plurality of locations of the storage element an encryption program in execution; extracting encrypted instructions of the encrypted program in execution; and Using the repaired value of the field, the decryption key data stored in the location indicated by the storage element is used to decrypt the extracted encrypted instruction. 84. The method of operation of claim 83, further comprising: Before decrypting the extracted encrypted instruction, the stored decryption key data is loaded into an extraction unit of the microprocessor at the position indicated by the repaired value of the field in the storage element. 85. The method of operation of claim 83, further comprising: configuring a plurality of locations on the storage element to store decryption key data required for a new encryption program to be executed by the microprocessor; setting the value of the field of the control register to indicate the position allocated in the storage element by the above allocation step; and. The decryption key data of the new encryption program is loaded into the location configured in the storage element in the above configuration step. 86. The operation method as claimed in claim 83, wherein the step of decrypting the extracted encrypted instruction comprises extracting the stored decryption key data at the position indicated by the storage element with the repaired value of the field The encrypted instruction performs Boolean XOR operation. 87. The method of operation of claim 83, further comprising: In response to the above-mentioned return operation from the interrupt command, if the value after the repair of the field is set in the corresponding bit of the position indicated by the storage element, an abnormal warning is issued before decrypting the extracted encrypted command. 88. The method of operation of claim 87, further comprising: Responding to the abnormal warning, before decrypting the extracted encryption instruction, reload the decryption key data of the encryption program in execution into the position indicated by the repaired value of the field in the storage element. 89. The method of operation of claim 87, further comprising: Before the above-mentioned operation returning from the interrupt instruction is executed, overwrite and cover the decryption key data stored in the corresponding position of the encryption program to be restarted on the storage element; Leave this bit set to indicate that the above-mentioned overwrite operation has occurred. 90. The method of operation of claim 89, further comprising: Determining that the storage element does not have enough free space for a new encryption program to be executed by the microprocessor; Wherein, in response to the above-mentioned step of determining that the storage element does not have enough free space, the location in the storage unit is allocated to the new encryption program in an overwriting manner. 91. The method of operation of claim 89, wherein, In response to the abnormal warning, the decryption key data corresponding to the executed program is reloaded into the position indicated by the repaired value of the field in the storage element by overwriting. 92. The method of operation of claim 83, further comprising: receive a request to implement a new encryption procedure; and When the storage element does not have enough free space to store the decryption key data of the new encryption program, the new encryption program cannot be executed until the storage element is provided with enough free space. 93. A microprocessor comprising: A branch target address cache memory, which records historical information of previously executed branch and switch key instructions, wherein the above historical information includes the recorded target addresses and identifiers of the branch and switch key instructions, and the identifiers indicate the same Multiple key values related to the branch to which the key is switched; a fetch unit, coupled to the branch target address cache, and used for: receiving a prediction made by the branch target address cache when fetching previously executed branch and switch key instructions, and receiving the target addresses for the fetched branch and switch key instructions from the branch target address cache and the identifier; and extracting encrypted instruction data according to the received target address, and decrypting the extracted encrypted instruction data according to the plurality of key values indicated by the received identifier, in response to the received prediction. 94. The microprocessor as claimed in claim 93, wherein the extracting unit performs a Boolean XOR operation on the extracted encrypted command data and a decryption key to decrypt, wherein the decryption key is based on the received identifier The indicated key value is generated by a function. 95. The microprocessor of claim 93, wherein said identifier includes an index indicating a location within a register file for storing key values. 96. The microprocessor as claimed in claim 95, wherein the extraction unit further comprises: a master key register file, storing a plurality of key values required by the extracting unit to decrypt the extracted encrypted instruction data; and key switching logic, coupled to the branch target address cache and the master key register file, stores the index at a location indicated by the register file based on the index received from the branch target address cache The multiple key values of are used to update the master key register document above. 97. The microprocessor of claim 96, wherein if the branch target address cache prediction of the fetched branch and switch key instruction is incorrect, the microprocessor subsequently repairs the master key register file The value is the value before the update. 98. The microprocessor of claim 93, wherein the branch target address cache further records history information of previously executed legacy branch instructions, wherein, whether it is a branch and switch key instruction or a legacy branch instruction The history information, both including type indicators, indicates whether the recorded instruction is a branch and switch key instruction or a traditional branch instruction. 99. The microprocessor of claim 93, wherein the fetch unit generates a fetch address for fetching instructions from an instruction cache, wherein the fetch address is also used for accessing the branch target address cache. 100. The microprocessor as claimed in claim 93, wherein said history information further comprises adoption/non-adoption indicators of previously executed branch and switch key instructions, if the adopted/non-adopted indicators provided by the branch target address cache memory Using an index to predict that the currently fetched branch and switch key instructions will be taken, in response to the received prediction, the fetch unit fetches encrypted instruction data at the received target address and bases it on the received identifier as indicated Multiple key value decryption. 101. The microprocessor of claim 93, wherein the microprocessor is exempt from flushing if the microprocessor subsequently determines that the branch target address cache has correctly predicted the fetched branch and switch key instruction pipeline itself. 102. The microprocessor of claim 93, wherein if the microprocessor executes a branch and switch key instruction and determines that the branch target address cache cannot predict the branch and switch key instruction operation, the microprocessor will: Empty its own pipeline; extracting encrypted instruction data according to a target address indicated by the branch and switch key instruction; and The extracted encrypted instruction data is decrypted according to a plurality of key values indicated by the branch and switch key instruction. 103. The microprocessor of claim 93, wherein the branch target address cache further stores history information of previously executed key switch instructions, wherein the history information of the key switch instructions includes identifiers, It is used to mark multiple key values related to the key switch command to which it belongs. Whether it is a branch and switch key command or a key switch command, it includes a type indicator, indicating that the recorded command belongs to the branch and switch The key command is also the key switching command. 104. A method of operating for operating a microprocessor, the method of operating comprising: Recording historical information of previously executed branch and switch key instructions in a branch target address cache register, wherein the above historical information includes the recorded target addresses and identifiers of the branch and switch key instructions, and the identifiers indicate the same Multiple key values related to the branch to which the key is switched; receiving a prediction made by the branch target address cache when fetching previously executed branch and switch key instructions, and receiving the target addresses for the fetched branch and switch key instructions from the branch target address cache and the identifier; and extracting encrypted instruction data according to the received target address, and decrypting the extracted encrypted instruction data according to the plurality of key values indicated by the received identifier, in response to the received prediction. 105. The operation method as claimed in claim 104, wherein the step of decrypting the extracted encrypted instruction data is to perform a Boolean XO operation between the extracted encrypted instruction data and a decryption key, wherein the decrypted key is obtained by The plurality of key values indicated by the received identifier are generated by a function. 106. The method of operation of claim 104, wherein said identifier comprises an index indicating a location within a register file for storing key values. 107. The method of operation of claim 106, further comprising: storing a plurality of key values required to decrypt the extracted encrypted command data with a master key register file; and based on the index received from the branch target address cache, using key values stored by the index at locations indicated by the register file to update the master key register file in response to receiving the prediction . 108. The method of operation of claim 107, further comprising: If the prediction of the extracted branch and switch key instruction by the branch target address cache memory is incorrect, then the value of the above-mentioned master key register file is restored to the value before updating. 109. The method of operation of claim 106, further comprising: Record the history information of previously executed traditional branch instructions in the branch target address block fetch memory, wherein, whether it is the branch and switch key instruction or the history information of the traditional branch instructions, all include type indicators, indicating that the recorded instructions belong to Branch and switch key instructions are traditional branch instructions. 110. The method of operation of claim 104, further comprising: generating a fetch address for fetching instructions from an instruction cache; and The branch target address cache is accessed with the fetch address. 111. The method of operation of claim 104, wherein, The above-mentioned historical information also includes adoption/non-adoption indicators of previously executed branch and switch key instructions. Employing, responsive to the received prediction, the method of operation includes extracting encrypted instruction data at the received target address and decrypting it based on a plurality of key values indicated by the received identifier. 112. The method of operation of claim 104, further comprising: If the microprocessor subsequently determines that the branch target address cache has correctly predicted the fetched branch and switch key instruction, flushing the microprocessor pipeline is omitted. 113. The method of operation of claim 104, further comprising: Execute a branch and switch key instruction; If it is determined that the branch target address cache memory cannot predict the operation of the branch and switch key instruction, then execute: emptying the pipeline of the microprocessor; extracting encrypted instruction data according to a target address indicated by the branch and switch key instruction; and The extracted encrypted instruction data is decrypted according to a plurality of key values indicated by the branch and switch key instruction. 114. The method of operation of claim 104, further comprising: Record the history information of the previously executed key switching instruction in the branch target address cache memory, wherein the above-mentioned history information of the key switching instruction includes an identifier, which is used to identify multiple encryption keys related to the key switching instruction. Key value, wherein, whether it is a branch and switch key command or a key switch command, it includes a type indicator, indicating whether the recorded command belongs to a branch and switch key command or a key switch command.

Images