Abstract:
A method of processing data includes receiving a request for an operand from a second processor at a first processor, encrypting the operand that has been requested using the first processor responsive to receiving the request for the operand, sending the operand that has been encrypted from the first processor to the second processor, receiving a result from the second processor at the first processor, the result generated from a single homomorphic operation being performed using the operand sent to the second processor, decrypting the result received from the second processor at the first processor, and receiving a request for the result that has been decrypted from the second processor at the first processor.

Description:
BACKGROUND 
     The present disclosure relates generally to the field of data security, and, more particularly, to methods, systems, and computer program products for performing homomorphic encryption and decryption. 
     It may be said that computing has taken over all aspects of the global economy. Increasingly, outsourced or out-tasked models for computing have become more prevalent, for example, “cloud computing,” in which an enterprise uses a third party&#39;s computing resources, such as servers and storage, to run an application under an on-demand, pay-per-use model, not unlike renting a car or hotel room. 
     One potential challenge in such a model is security. If an enterprise wants to run an application on some data, either the application may be proprietary, e.g., a trade secret trading algorithm used by a brokerage, or the data may be proprietary, e.g., customer purchases/identity information, or both. In the same way that a package transported by a third party logistics provider might get lost, data breaches have occurred where proprietary information is released to unauthorized recipients either accidentally or through the efforts of cyber-criminals. 
     A strategy for protecting data is encryption. Under traditional mechanisms the data may be encrypted at a point of origin in the enterprise data center and then carried across a network as ciphertext, but then must be decrypted at the point of destination to actually be processed. If the data is decrypted then the data is exposed to parties at the destination where the data is processed. If the data represents private or sensitive information then additional security measures may need to be taken to ensure that the data is not released to unauthorized parties. 
     One technique that may be used to allow third parties to process data in a secure manner is “homomorphic encryption,” which has the property that mathematical operations performed on the ciphertext are homomorphic, that is, the operations generate a resulting ciphertext that can be decrypted to generate a plaintext which equals the same result as if those operations were performed on the unencrypted operands. An example would be an encryption process of doubling and a decryption process of halving. If the plaintext value is 3 then the ciphertext value is 6. For an addition process, 6+6+6 equals 18, which when decrypted, i.e., halved, yields 9, which is identical to 3+3+3. 
     A homomorphic encryption process has been published by Craig Gentry that uses perfect lattices to enable numerous mathematical operations to be performed on encrypted data. While of theoretical interest, this proposed encryption process generally involves complex mathematical calculations, which means that even the simplest computations can take relatively long time periods. Moreover, even with parallelism, the computational overhead may outweigh potential savings from using cloud services that otherwise could provide economies of scale. 
     SUMMARY 
     It should be appreciated that this Summary is provided to introduce a selection of concepts in a simplified form, the concepts being further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of this disclosure, nor is it intended to limit the scope of the disclosure. 
     Some embodiments provide a method of processing data comprising receiving a request for an operand from a second processor at a first processor, encrypting the operand that has been requested using the first processor responsive to receiving the request for the operand, sending the operand that has been encrypted from the first processor to the second processor, receiving a result from the second processor at the first processor, the result generated from a single homomorphic operation being performed using the operand sent to the second processor, decrypting the result received from the second processor at the first processor, and receiving a request for the result that has been decrypted from the second processor at the first processor. 
     In other embodiments, the result is a first result and the single homomorphic operation is a single first homomorphic operation. The method further comprises encrypting the first result that has been requested using the first processor responsive to receiving the request for the first result, sending the first result that has been encrypted from the first processor to the second processor, receiving a second result from the second processor at the first processor, the second result generated from a single second homomorphic operation being performed using the first result sent to the second processor, and decrypting the second result received from the second processor at the first processor. 
     In still other embodiments, the first processor and second processor are coupled via an untrusted communication network. 
     In still other embodiments, the first processor and the second processor are in a same integrated circuit device. 
     In still other embodiments, the first processor and the second processor are separate virtual machines that execute on a common hardware platform. 
     In still other embodiments, each of the operand has a multiplicative encryption pad and an additive encryption pad associated therewith. 
     In still other embodiments, decrypting the result comprises selecting for the operand one of the multiplicative encryption pad and the additive encryption pad associated with the operand based on the single homomorphic operation and using the selected multiplicative encryption pad or additive encryption pad to decrypt the result. 
     In still other embodiments, the single homomorphic operation is an addition operation and wherein selecting for the operand one of the multiplicative encryption pad and the additive encryption pad comprises selecting for the operand, the additive encryption pad. 
     In still other embodiments, the single homomorphic operation is a multiplication operation and wherein selecting for the operand one of the multiplicative encryption pad and the additive encryption pad comprises selecting for the operand the multiplicative encryption pad. 
     In still other embodiments, the single homomorphic operation is a copy operation and wherein selecting for the operand one of the multiplicative encryption pad and the additive encryption pad comprises selecting for the operand the additive encryption pad. 
     In still other embodiments, the single homomorphic operation is a negation operation and wherein selecting for the operand one of the multiplicative encryption pad and the additive encryption pad comprises selecting for the operand the additive encryption pad. 
     In still other embodiments, the single homomorphic operation is an inversion operation and wherein selecting for the operand one of the multiplicative encryption pad and the additive encryption pad comprises selecting for the operand the multiplicative encryption pad. 
     In further embodiments, a data processing system comprises a memory comprising computer readable program code and a first processor that is coupled to the memory and is configured to execute the computer readable program code so as to cause the data processing system to receive a request for an operand from a second processor, to encrypt the operand that has been requested responsive to receiving the request for the operand, to send the operand that has been encrypted to the second processor, to receive a result from the second processor, the result generated from a single homomorphic operation being performed using the operand sent to the second processor, to decrypt the result received from the second processor, and to receive a request for the result that has been decrypted from the second processor at the first processor. 
     In still further embodiments, the first processor and second processor are coupled via an untrusted communication network. 
     In still further embodiments, the first processor and the second processor are in a same integrated circuit device. 
     In still further embodiments, the first processor and the second processor are separate virtual machines that execute on a common hardware platform. 
     In other embodiments, an article of manufacture comprises a non-transitory computer readable storage medium having computer readable program code embodied therein. The computer readable program code comprises computer readable program code configured to receive a request for an operand from a second processor at a first processor, computer readable program code configured to encrypt the operand that has been requested using the first processor responsive to receiving the request for the operand, computer readable program code configured to send the operand that has been encrypted from the first processor to the second processor, computer readable program code configured to receive a result from the second processor at the first processor, the result generated from a single homomorphic operation being performed using the operand sent to the second processor, computer readable program code configured to decrypt the result received from the second processor at the first processor, and computer readable program code configured to receive a request for the result that has been decrypted from the second processor at the first processor. 
     In still other embodiments, the first processor and second processor are coupled via an untrusted communication network. 
     In still other embodiments, the first processor and the second processor are in a same integrated circuit device. 
     In still other embodiments, the first processor and the second processor are separate virtual machines that execute on a common hardware platform. 
     Other methods, systems, devices, appliances, and/or computer program products according to embodiments of the invention will be or become apparent to one with skill in the art upon review of the following drawings and detailed description. It is intended that all such additional systems, methods, and/or computer program products be included within this description, be within the scope of the present invention, and be protected by the accompanying claims. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       Other features of exemplary embodiments will be more readily understood from the following detailed description of specific embodiments thereof when read in conjunction with the accompanying drawings, in which: 
         FIG. 1  is a block diagram that illustrates a system for performing homomorphic encryption and decryption on individual operations in accordance with some embodiments; 
         FIG. 2  is a diagram that illustrates encryption of operands using associated multiplicative and additive pads according in accordance with some embodiments; and 
         FIGS. 3-10  are flowcharts that illustrate operations for performing homomorphic encryption and decryption on individual operations in accordance with some embodiments. 
     
    
    
     DETAILED DESCRIPTION 
     While the invention is susceptible to various modifications and alternative forms, specific embodiments thereof are shown by way of example in the drawings and will herein be described in detail. It should be understood, however, that there is no intent to limit the invention to the particular forms disclosed, but on the contrary, the invention is to cover all modifications, equivalents, and alternatives falling within the spirit and scope of the invention as defined by the claims. Like reference numbers signify like elements throughout the description of the figures. 
     As used herein, the singular forms “a,” “an,” and “the” are intended to include the plural forms as well, unless expressly stated otherwise. It should be further understood that the terms “comprises” and/or “comprising” when used in this specification is taken to specify the presence of stated features, integers, steps, operations, elements, and/or components, but does not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof. It will be understood that when an element is referred to as being “connected” or “coupled” to another element, it can be directly connected or coupled to the other element or intervening elements may be present. Furthermore, “connected” or “coupled” as used herein may include wirelessly connected or coupled. As used herein, the term “and/or” includes any and all combinations of one or more of the associated listed items. 
     Unless otherwise defined, all terms (including technical and scientific terms) used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention belongs. It will be further understood that terms, such as those defined in commonly used dictionaries, should be interpreted as having a meaning that is consistent with their meaning in the context of the relevant art and this specification and will not be interpreted in an idealized or overly formal sense unless expressly so defined herein. 
     Exemplary embodiments may be embodied as methods, systems, and/or computer program products. Accordingly, exemplary embodiments may be embodied in hardware and/or in software (including firmware, resident software, micro-code, etc.). Furthermore, exemplary embodiments may take the form of a computer program product comprising a computer-usable or computer-readable storage medium having computer-usable or computer-readable program code embodied in the medium for use by or in connection with an instruction execution system. In the context of this document, a computer-usable or computer-readable medium may be any medium that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device. 
     The computer-usable or computer-readable medium may be, for example but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, device, or propagation medium. More specific examples (a nonexhaustive list) of the computer-readable medium would include the following: an electrical connection having one or more wires, a portable computer diskette, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, and a portable compact disc read-only memory (CD-ROM). Note that the computer-usable or computer-readable medium could even be paper or another suitable medium upon which the program is printed, as the program can be electronically captured, via, for instance, optical scanning of the paper or other medium, then compiled, interpreted, or otherwise processed in a suitable manner, if necessary, and then stored in a computer memory. 
     Some embodiments described herein may provide methods, systems, and computer program products for performing homomorphic encryption and decryption on operands and results used in individual mathematical and/or logical operations. The encryption and decryption operations may generally involve a relatively small number of additional steps and the total computation times may scale linearly based on the number of processor instructions executed for an application. This may allow, for example, two parties to cooperate to generate a result without either party having to reveal private information to the other. For example, one party may have private data and wishes to have that data processed by a proprietary algorithm owned by another party. The first party has access to the data, but not the algorithm while the second party has access to the algorithm, but not the unencrypted data. The party owning the algorithm may access encrypted versions of the data and may perform homomorphic mathematical and/or logical operations on the data. After each individual homomorphic operation the result is returned to the data owner where it is unencrypted. The result may be encrypted again and provided to the algorithm owner should the algorithm need the result for further computations. 
     According to some embodiments for performing homomorphic encryption and decryption on operands and results used in individual mathematical and/or logical operations described herein, a set of n plaintext operands/variables P 1 , P 2 , . . . P n  are maintained by a first party. A mathematical transformation and encryption function E( ) uses dynamically (re)generated one-time random multiplicative pads, R 1 , R 2 , . . . R n  to generate a set of n ciphertext operands C 1 , C 2 , . . . C n , so that C i =E(P i )=R i *P i . Homomorphic operations may then be performed on the ciphertext, where, after each individual operation, the result is stored, decrypted, and potentially re-encrypted. Before and after every homomorphic operation, the relationship between P, R, and C ensures that C i =P i *R i , except when P i=0  there is special handling. As described below, a corresponding additive pad may be generated for each multiplicative pad. A decryption operation may use one or more multiplicative pad or one or more additive pad depending on the type of homomorphic operation that was performed on the ciphertext operand(s). 
       FIG. 1  is a block diagram of a system  100  for performing homomorphic encryption and decryption on individual operands and results of operations on operands in accordance with some embodiments. The system  100  comprises a trusted network  110 , a data storage module  120 , an untrusted network  130 , and a compute module  140 . Private data may exist elsewhere in the trusted environment (not shown), and arrive at the data storage module  120  via the trusted network  110 . Such data may arrive as a single array, an array of structures, a relational database, Javascript Object Notation, XML, and/or other mechanisms according to various embodiments, and are reliably received or transmitted by a trusted network interface  121 . Data may be assumed to be private, in which case it is all stored in a private data store  122 , or may be a mix of private and public data, in which case markings or other means may be used to indicate which is private and should be stored in the private data store  122 , and which is public and may be stored in a public data store  123 . An encryption/decryption unit  124  encrypts private data from the private data store  122  using one-time pads generated by a one-time pad generator  125  which are saved in a pad data store  126 . The encryption/decryption unit  124  also decrypts the resulting ciphertext data generated by the compute module  140  after performing a homomorphic operation on one or more encrypted operands provided by the data storage module  120 . After encryption, encrypted data may be stored in an encrypted data store  127 . Read requests for encrypted data or for public data are managed by an untrusted compute network interface  128 , which can read from the Public Data Store  123 , read from the encrypted data store  127 , write to the public data store  123 , and/or write to the encrypted data store  127  via a command processor  129 . In accordance with various embodiments, the data storage module  120  may be implemented as a special purpose device or embedded system that can be used to provide data received from the trusted network  110  to the compute module  140  in a secure fashion or may be implemented as a logical part of general purpose computing system. 
     The compute module  140  includes an instruction processor  144 , which fetches instructions from an instruction store  145  in accordance with the pointer contained in an instruction register  143 . Some instructions are GoTos or jumps, which merely alter the value of the instruction register  143 . Some are mathematical or logical operations, which then may involve the use of an arithmetic/logic Unit  146 . The arithmetic/logic unit  146  may use local data for processing, such as data maintained in a local data store  142 , for example, and/or temporary registers. The arithmetic/logic unit  146  may also need access to data in the data storage module  120 . If so, it accesses either public data or encrypted private data via a compute-side network interface  141 , which communications with the untrusted compute network interface  128  via the untrusted network  130 . 
     It will be appreciated that these modules shown in  FIG. 1  may be implemented in various ways and at various scales in accordance with various embodiments. For example, in one implementation, the trusted network  110  may be an enterprise data center LAN, the untrusted network  130  may be a public service provider&#39;s Wide Area Network, VPN service, and/or the Internet, components of the data storage module  120  may be built as software running on a hypervisor residing on a compute server while the private data store  122 , public data store  123 , and pad data store  126  may be implemented via one or more enterprise storage arrays. 
     The data storage module  120  and the compute module  140  are not limited to a particular type of implementation configuration. For example, in some embodiments, the data storage module  120  and the compute module  140  may be implemented as separate physical servers co-located in a single facility. The data storage module  120  and the compute module  140  may also be separated geographically in separate facilities, regions, or even countries. In yet other embodiments, the data storage module  120  and the compute module  140  may be implemented as separate virtual machines on a common hardware platform. 
     In still other embodiments, the entirety of the system  100  may be built as a “core” on a multi-core integrated circuit device, with the trusted network  110  implemented as an on-chip I/O port, the private data store  122  and the other data stores implemented as on-chip registers, and the untrusted network  130  implemented as on-chip data transport. 
     Thus, in accordance with various embodiments, the trusted network  110  and the untrusted network  130  may represent a global network, such as the Internet, or other publicly accessible network. The trusted network  110  and the untrusted network  130  may also, however, represent a wide area network, a local area network, an Intranet, or other private network, which may not accessible by the general public. Furthermore, the trusted network  110  and the untrusted network  130  may represent a combination of public and private networks or a virtual private network (VPN). It will be appreciated that in various alternate embodiments the untrusted network  130  may use low level bus commands to facilitate communications between the data storage module  120  and the compute module  140  when implemented on the same integrated circuit, or, for example, may use application layer software function calls when executed in a metro or wide-area context. Such calls or messages may be implemented as Remote Procedure Calls, SOAP/XML messages, or other means. The encrypt/decrypt unit  124 , one-time pad generator  125 , command processor  129 , instruction processor  144 , and arithmetic/logic unit  146  may be implemented as one or more commercially available or custom microprocessors. The private data store  122 , public data store  123 , pad data store  126 , encrypted data store  127 , local data store  142 , and instruction store  145  comprises memory that is representative of the one or more memory devices containing software and data used for performing homomorphic encryption and decryption on individual operations in accordance with some embodiments. This memory may include, but is not limited to, the following types of devices: cache, ROM, PROM, EPROM, EEPROM, flash, SRAM, and DRAM. 
     Although  FIG. 1  illustrates an exemplary system for performing homomorphic encryption and decryption on individual operations in accordance with some embodiments, it will be understood that embodiments of the present invention are not limited to such configurations, but are intended to encompass any configuration capable of carrying out the operations described herein. 
       FIG. 2  is a diagram that illustrates encryption of operands using associated multiplicative and additive pads according in accordance with some embodiments. As shown in  FIG. 2 , there are n operands 1 through n that exist in plaintext P i  and Ciphertext C i . P i  and C i  may be related by two random pads M i  and A i . M i  is the multiplicative pad and A i  is the additive pad, such that P i +A i =C i  and P i *M i =C i . Such a pair of pads may be generated as follows: 
     If P i &lt; &gt;0 generate a non-zero random pad M i . Generate C i  from P i  and M i  by setting C i  to P i *M i . Then, determine A i  as C i −P i . For example, suppose P i  is 7. Generate a random M i , such as 3.1. Then, generate C i  as P i *M i , namely 7 *3.1=21.7. Then, determine A i  as C i −P 1 , namely 21.7−7 which is 14.7. Now P i=7 , M i=3.1 , A i=14.7 , and =21.7. Thus, the desired relationships hold. It will be appreciated that Ai may be generated first to be not equal to—P i , and then M i  generated as a dependent variable. 
     Although the operations shown here are conducted on rational numbers, such as 7 *3.1=21.7, it may be appreciated that in other embodiments the plaintext values and the ciphertext values may all be integers, with the one-time pads being either integers or rational numbers. As an example, if P i  is 7, the random M i  may be selected to be 3, so that C i  is 7 *3=21. Then, A i  is 21−7 which is 14. It will be appreciated, however, that an untrusted process running on a second processor may then use unique factorization to deduce over time that P i  is 7. 
     To prevent this, rational numbers that are fractions may be generated, thus “blinding” the second processor to the value of the private data. For example, a one-time pad M i  of 4/7 may be used, generating a C i  that is 7* 4/7=4, and therefore A i  of 4−7=−3. To achieve this, the plaintext operand is uniquely factored, and a pad is generated by creating a fraction whose numerator is a randomly generated non-zero integer and whose denominator is a randomly selected divisor of the prime factors of P i . 
     If P i=0 , a different method is used. First, generate a non-zero random pad A i . Then, set C i  to equal P i +A i . Mark M i  as N/A as it will be ignored during subsequent calculations. It will be understood that P i  cannot be determined by an untrusted process that can only view the ciphertext C i .  FIG. 2  illustrates various examples of plaintext values and ciphertext values generated using multiplicative or additive pads. Because the one-time pads are not visible to the untrusted process, they cannot be “backed out” to generate P i  from C i . However, ciphertext can be used in mathematical and/or logical operations to generate homomorphically encrypted results, which then may be decrypted to determine equivalent plaintext results. 
     Computer program code for carrying out operations of data processing systems discussed above with respect to  FIGS. 1 and 2  may be written in a high-level programming language, such as Java, C, and/or C++, for development convenience. In addition, computer program code for carrying out operations of the present invention may also be written in other programming languages, such as, but not limited to, interpreted languages. Some modules or routines may be written in assembly language or even micro-code to enhance performance and/or memory usage. Embodiments described herein, however, are not limited to any particular programming language. It will be further appreciated that the functionality of any or all of the program modules may also be implemented using discrete hardware components, one or more application specific integrated circuits (ASICs), or a programmed digital signal processor or microcontroller. 
     Exemplary embodiments are described herein with reference to flowchart and/or block diagram illustrations of methods, systems, and computer program products in accordance with exemplary embodiments. These flowchart and/or block diagrams further illustrate exemplary operations for performing homomorphic encryption and decryption on individual operations, in accordance with some embodiments. It will be understood that each block of the flowchart and/or block diagram illustrations, and combinations of blocks in the flowchart and/or block diagram illustrations, may be implemented by computer program instructions and/or hardware operations. These computer program instructions may be provided to a processor of a general purpose computer, a special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means and/or circuits for implementing the functions specified in the flowchart and/or block diagram block or blocks. 
     These computer program instructions may also be stored in a computer usable or computer-readable memory that may direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer usable or computer-readable memory produce an article of manufacture including instructions that implement the function specified in the flowchart and/or block diagram block or blocks. 
     The computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions that execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart and/or block diagram block or blocks. 
     Referring now to  FIG. 3  and  FIG. 1 , exemplary operations for performing homomorphic encryption and decryption on individual operations in accordance with some embodiments begin at block  300  where the data storage module  120  receives a request for one or more operands from the compute module  140 . The encrypt/decrypt unit  124  encrypts the one or more operands at block  305  and sends the encrypted one or more operands to the compute module via the untrusted computer network interface  128  over the untrusted network  130  at block  310 . After the compute module  140  performs a single homomorphic operation on the one or more operands using the instruction processor  144  and/or the arithmetic/logic unit  146 , the result of the single homomorphic operation is sent to the data storage module  120  via the compute side network interface  141  over the untrusted network  130  where it is received by the data storage module  120  at block  315 . The encrypt/decrypt unit  124  decrypts the result received from the compute module  140  at block  320 . The decrypted result may be stored in the private data store  122 , public data store  123 , or may be re-encrypted and stored in the encrypted data store  127  where it may be provided as an operand to the compute module  140  for use in a subsequent computation. 
     Example homomorphic operations that may be performed by the compute module  140  include, but are not limited to, the following types of machine language instructions, which reside at numbered instruction addresses: 
     ADD operand 1 , operand 2 , result 
     MULTIPLY operand 1 , operand 2 , result 
     COPY operand 1 , operand 2   
     INVERT operand 1 , result 
     NEGATE operand 1 , result 
     GOTO instruction_number 
     END 
       FIGS. 4-10  are flowcharts that illustrate operations in executing these machine language instructions on the compute module  140  using encrypted operands provided by the data storage module  120  according to some embodiments. Referring to  FIGS. 4 and 1 , operations begin at block  400  where the instruction processor  144  reads an instruction from the instruction store  145  based on the value of the instruction register  143  to determine the type of instruction. If the operation is an add instruction as determined at block  405 , then operations continue at  FIG. 5  where first and second ciphertext operands C i  and C j  are read from the data storage module  120  at blocks  500  and  505 , respectively. The arithmetic/logic unit  146  generates the resulting sum C k  at block  510  and writes the result C k  to the data storage module  120  at block  515 . The encrypt/decrypt unit  124  decrypts the result C k  at block  520  by subtracting the additive pads A i  and A j  from the result C k , to generate the plaintext value P k  at block  520 . New pads A k  and M k  may be generated for the resulting plaintext value P k  at block  525  and the plaintext result may be encrypted to generate a ciphertext value C k . The instruction register  143  is incremented at block  530  to process the next instruction. 
     Returning to  FIG. 4 , if the operation is a multiply operation as determined at block  410 , then operations continue at  FIG. 6  where first and second ciphertext operands C i  and C j  are read from the data storage module  120  at blocks  600  and  605 , respectively. The arithmetic/logic unit  146  generates the resulting product C k  at block  510  and writes the result C k  to the data storage module  120  at block  615 . If both of the plaintext operands were non-zero as determined at block  620 , then the encrypt/decrypt unit  124  decrypts the result C k  at block  520  by dividing the result C k  by the multiplicative pads M i  and M j  to generate the plaintext value P k  at block  630 . If, however, at least one of the plaintext operands was zero, then the decrypted result P k  is set to zero at block  625 . New pads A k  and M k  may be generated for the resulting plaintext value P k  at block  635  and the plaintext result may be encrypted to generate a ciphertext value C k . The instruction register  143  is incremented at block  640  to process the next instruction. 
     Returning to  FIG. 4 , if the operation is a copy operation as determined at block  415 , then operations continue at  FIG. 7  where a first ciphertext operand C i  is read from the data storage module  120  at block  700 . The arithmetic/logic unit  146  copies the ciphertext operand C i  to C j  at block  705  and writes the result C j  to the data storage module  120  at block  710 . The encrypt/decrypt unit  124  decrypts the result C j  by subtracting the additive pad A i  from the result C j  to generate the plaintext value P j  at block  715 . New pads A j  and M j  may be generated for the resulting plaintext value P j  at block  720  and the plaintext result may be encrypted to generate a ciphertext value C j . The instruction register  143  is incremented at block  725  to process the next instruction. 
     Returning to  FIG. 4 , if the operation is an invert operation as determined at block  420 , then operations continue at  FIG. 8  where a first ciphertext operand C i  is read from the data storage module  120  at block  800 . The arithmetic/logic unit  146  inverts the ciphertext operand C i  to generate C j  at block  805  and writes the result C j  to the data storage module  120  at block  810 . The encrypt/decrypt unit  124  decrypts the result C i  at block  815  by dividing the result C j  by the multiplicative pad M i  and then inverting this intermediate result to generate the plaintext value P j  at block  815 . New pads A j  and M j  may be generated for the resulting plaintext value P j  at block  820  and the plaintext result may be encrypted to generate a ciphertext value C j . The instruction register  143  is incremented at block  825  to process the next instruction. 
     Returning to  FIG. 4 , if the operation is a negate operation as determined at block  425 , then operations continue at  FIG. 9  where a first ciphertext operand C i  is read from the data storage module  120  at block  900 . The arithmetic/logic unit  146  negates the ciphertext operand C i  to generate C j  at block  905  and writes the result C j  to the data storage module  120  at block  910 . The encrypt/decrypt unit  124  decrypts the result C j  by subtracting the additive pad A i  from the result C j  and then subtracting this intermediate result from zero to generate the plaintext value P j  at block  925 . New pads A j  and M j  may be generated for the resulting plaintext value P j  at block  930  and the plaintext result may be encrypted to generate a ciphertext value C j . The instruction register  143  is incremented at block  935  to process the next instruction. 
     Returning to  FIG. 4 , if the operation is a jump operation as determined at block  430 , then operations continue at  FIG. 10  where the instruction register  143  is set to the new address at block  1000 . 
     Returning to  FIG. 4 , operations end if a determination is made at block  435  that program execution is complete. 
     The flowcharts of  FIGS. 4-10  illustrate the architecture, functionality, and operations of some embodiments of methods, systems, and computer program products for performing homomorphic encryption and decryption on individual operations. In this regard, each block represents a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that in other implementations, the function(s) noted in the blocks may occur out of the order noted in  FIGS. 4-10 . For example, two blocks shown in succession may, in fact, be executed substantially concurrently or the blocks may sometimes be executed in the reverse order, depending on the functionality involved. 
     The foregoing examples described with respect to  FIGS. 4-10  illustrate single homomorphic operations that can be performed on encrypted operands and then the encrypted results decrypted to generate plaintext results in accordance with some embodiments of the present invention. It will be understood, however, that these examples are for purposes of illustration and other homomorphic mathematical and/or logical operations may also be used. 
     The flowcharts of  FIGS. 3-10  illustrate the architecture, functionality, and operations of some embodiments of methods, systems, and computer program products for performing homomorphic encryption and decryption on operands and results used in individual mathematical and/or logical operations. In this regard, each block represents a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that in other implementations, the function(s) noted in the blocks may occur out of the order noted in  FIGS. 3-10 . For example, two blocks shown in succession may, in fact, be executed substantially concurrently or the blocks may sometimes be executed in the reverse order, depending on the functionality involved. 
     According to the embodiments described herein encrypted data may be provided to an external party for processing without that party having visibility into the original plaintext data. The external party may generate results based on the encrypted data, which can be provided back to the party owning the original plaintext data. The encrypted results can be decrypted by the owner of the plaintext data to obtain values that are the same as if the external party had processed the original plaintext data directly. This may allow data owners to transmit their data to third parties operating “cloud computing” centers where the data may be processed without breaching any confidentiality associated with the data. 
     It will be appreciated that the systems, methods, and computer program products described above generally, and the one-time pads and specific set of operators described above specifically, may enable fully secure processing by the second processor of operations including multiplication and addition. It is known that such operations are the only operations required to compute a “boolean circuit,” and thus suffice to perform any general computation. 
     Moreover, the one-time pads ensure that the second processor cannot determine any information regarding the private unencrypted data. However, this core “trusted” set of operations can be expanded to include public data or operations that do not singly reveal any information. Such variations may be desirable for some computations. As an example, consider a general purpose function, such as calculating x to the nth power, x n . The two things that are required are x and n—x can be encrypted, but n must be known. For this purpose, the public data store  123  may be used with the untrusted computer network Interface  128  accessing private encrypted data from the encrypted data store  127  (in this case, the “x”) and public data from the public data store  123  (in this case, the “n”). It will be appreciated that, in conjunction with such use, additional operations may be provided to extend the instruction set that the instruction processor  144  may recognize. These may include, but are not limited to, instructions such as the following: 
     INCREMENT operand 1   
     DECREMENT operand 1   
     JUMP ON ZERO operand 1 , instruction_number 
     JUMP ON LESS THAN ZERO operand 1 , instruction_number 
     This is a representative set of operations and is intended to be illustrative, not limiting. It will be appreciated that the command processor  129 , with knowledge of which data is private and which is public, may adjust calculations accordingly to permit mixed operations, such as “MULTIPLY encrypted_operand, unencrypted_operand, result.” Not only may the embodiments described herein be used in their pure form, but as a hybrid that comprises encrypted and unencrypted portions, and, in the limit, may be capable of executing the entire instruction set of any modern processor. 
     Many variations and modifications can be made to the preferred embodiments without substantially departing from the principles of the present invention. All such variations and modifications are intended to be included herein within the scope of the present invention, as set forth in the following claims.