Abstract:
A field configurable device, such as an FPGA, supports secure field configuration without using non-volatile storage for cryptographic keys on the device and without requiring a continuous or ongoing power source to maintain a volatile storage on the device. The approach can be used to secure the configuration data such that it can in general be used on a single or a selected set of devices and/or encryption of the configuration data so that the encrypted configuration data can be exposed without compromising information encoded in the configuration data.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
     This application is a continuation of U.S. application Ser. No. 11/272,995, which issued as U.S. Pat. No. 7,702,927 on Apr. 20, 2010, which claims the benefit of the following U.S. Provisional Application Ser. No. 60/627,605, filed Nov. 12, 2004; No. 60/629,953, filed Nov. 22, 2004; and No. 60/647,575, filed Jan. 27, 2005. Each of these applications is incorporated herein by reference. 
     This application is also related to U.S. application Ser. No. 11/273,920, which issued as U.S. Pat. No. 7,564,345 on Jul. 21, 2009, which is also incorporated herein by reference. 
     This application is also related to U.S. application Ser. No. 10/407,603, titled “Authentication of Integrated Circuits,” filed on Apr. 4, 2003, and published on Oct. 30, 2003, as US2003/0204743A1, which is also incorporated herein by reference. 
    
    
     BACKGROUND 
     This invention relates to secure configuration of a field configurable logic device. 
     Field configurable devices, such as field programmable gate arrays (FPGAs), are typically configured using data that is supplied to the device after the device is deployed in an application. For example, the configuration data is provided to the device when the device is powered on. 
     It may be desirable to avoid disclosure of the configuration data. For example, the configuration data may include secrets, such as cryptographic keys or procedures, that are necessary to keep private. It may be also desirable to prevent configuration of the device with unauthorized configuration data. 
     Referring to  FIG. 1 , one approach that has been used to provide security for an FPGA  110  is to implement a decryptor function  140  (e.g., a 3DES decryptor) and a volatile memory function  120  (e.g., static RAM) on the same devices as the configurable logic  150 . The volatile memory holds a cryptographic key  125  that is provided to the decryptor function. Configuration data  160  for the device is provided to the device in an encrypted form  180  and a configuration module  145  uses the decryptor  140  to decrypt the configuration data as it is loaded into the device before it is used to configure the configurable logic. The cryptographic keys are set and stored on the device before it is deployed, and a dedicated battery  130  is used to maintain the volatile memory—if the battery is removed then the keys are erased. The provider of the configuration data knows the keys stored in the device and therefore can encrypt ( 170 ) the configuration data suitably for a particular device. An example of this approach is type of approach is commercially available in the Xilinx Virtex II™ family of FPGAs. 
     Authentication of integrated circuits has been suggested using device characteristics that vary from device to device based on variation in the fabrication process. Some such approaches are described in US Application Publication US2003/0204743A1, titled “Authentication of Integrated Circuits,” which is incorporated herein by reference. 
     SUMMARY 
     In a general aspect, a field configurable device, such as an FPGA, supports secure field configuration without using non-volatile storage for cryptographic keys on the device and without requiring a continuous or ongoing power source to maintain a volatile storage on the device. The approach can be used to secure the configuration data such that it can in general be used on a single or a selected set of devices and/or encryption of the configuration data so that the encrypted configuration data can be exposed without compromising information encoded in the configuration data. 
     One approach to generating decryption keys needed for loading of encrypted configuration data makes use of variations in the fabrication process for the FPGAs. The variations from device to device are used to internally generate the decryption key so that encrypted configuration data is not exposed in unencrypted form outside the FPGA. Because the decryption key is generated rather than stored inside or external to the FPGA, the key is difficult if not impossible to obtain from the FPGA itself. 
     In another aspect, in general, an electronic device includes a configuration module that provides an interface to the device for data for configuring logic on the device. The configuration data includes encrypted configuration data. The device also includes a first module that includes circuitry for generating a volatile response that varies among devices fabricated according to a same design as the device. A cryptographic module is coupled to the first module and to the configuration module. The cryptographic module is configured to decrypt the encrypted configuration data according to the response generated by the first module. 
     Aspect can include one or more of the following features. 
     The device includes a programmable gate array, and the configuration module is adapted to configure the programmable gate array according to the decrypted configuration data. 
     The first module is implemented using dedicated logic on the device and/or is implemented using configurable logic on the device. 
     The first module is configured to provide a key value to the cryptographic module determined using the volatile response. 
     The first module is configured to (a) accept a first input value and generate the volatile response based on the first input value, and/or (b) accept a second input value and combine the volatile response and the second input value to determine the key value. 
     The device includes a non-volatile storage for at least one of the first input value and the second input value. 
     At least one of the first input value and the second input value is provided to the device. 
     The first module is configured to accept the first input value and to generate the volatile response based on the first input value. 
     The first module is configured to accept the second input value and to combine the volatile response and the second input value to determine the key value. 
     The first module is configured accept a first input value and to generate the volatile response based on the first input value. 
     The device includes circuitry to prevent disclosure of the volatile response based on an input of the first value to the device. 
     In another aspect, in general, a method for configuring an electronic device includes providing configuration data to the device. The configuration data includes encrypted configuration data. A volatile key is generated using circuitry in the device. The key is used to decrypt the encrypted configuration data within the device. Logic on the device is then configured using the decrypted configuration data. 
     Aspects can include one or more of the following features. 
     Configuring the device includes configuring a programmable gate array according to the decrypted configuration data. 
     All information stored on the device from which the volatile key can be determined is cleared prior to generating the volatile key. 
     Generating the volatile key is performed without the device receiving information from which the volatile key can be determined subsequent to the clearing of the information. 
     Providing the configuration data to the device includes providing data for configuring logic on the device to form at least part of the circuitry used to generate the volatile key. 
     Providing the configuration data to the device includes providing data for configuring logic on the device to implement at least part of the decryption of the encrypted configuration data. 
     Generating the volatile key includes generating a volatile response. 
     A first input value is provided to the device that is used to generate the volatile response based. 
     A second input value is provided to the device. The volatile response and the second input value are combined to determine the volatile key. 
     At least one of the first value and the second value are stored in a non-volatile storage on the device. 
     At least one of the first value and the second value are determined such that a desired volatile key is generated. 
     In another aspect, in general, a method for configuring an electronic device includes forming first configuration data for the device. The first configuration data includes data for forming a first module for generating a volatile response that varies among like devices configured according to the configuration data. The device is configured using the first configuration data. A first volatile response is generated from the first module using the configured device. A signal is output from the device that depends on the volatile response. 
     Aspects can include one or more of the following features. 
     Second configuration data for the device is formed based on the outputted signal. The second configuration data includes data for forming the first module and data for implementing a comparison of the first volatile response and a volatile response generated by the first module according to the second configuration data. 
     The device is configured using the second configuration data. 
     The device is operated as configured using the second configuration data. This operation includes comparing the first volatile response and a volatile response generated by the first module and selectively inhibiting operation of functionality specified in the second configuration data depending on the comparison. 
     The second configuration data includes data for inhibiting operation of functionality specified in the second configuration data depending on the comparison. 
     The second configuration data includes data representing a value determined from the outputted signal. 
     In another aspect, in general, a method for authorizing use of configuration data features determining a volatile response generated by each of a set of configurable electronic devices. The volatile responses are each stored in association with an identifier for each of the devices. An identifier of one of the devices is later accepted from a user of the device. Authorization data based on the stored volatile response associated with the accepted identifier is then provided to the user. 
     Aspects can include one or more of the following. 
     The authorization data permits use of protected configuration data on the device. 
     A system that incorporates the device is configured according to the authorization data. 
     Accounting data is stored based on providing of authorization data to users. 
     The identifier from the user is passed over a public data network, and the authorization data is passed to the user of the public data network. 
     Aspects can have one or more of the following advantages. 
     Implementation of a volatile key generator in the field configurable device avoids the need for a battery to maintain cryptographic keys in the device. Use of a volatile key makes it difficult or impossible to access the key, thereby maintaining the security of data that requires the key for decryption. 
     Other features and advantages of the invention are apparent from the following description, and from the claims. 
    
    
     
       DESCRIPTION OF DRAWINGS 
         FIG. 1  is a diagram illustrating use of a battery-powered key storage on an FPGA. 
         FIG. 2  is a diagram illustrating use of a physically unclonable function (PUF) circuit on an FPGA. 
         FIGS. 3A and 3B  are diagrams illustrating PUF modules. 
         FIG. 4  is a diagram illustrating use of static storage in a PUF module. 
         FIG. 5  is a diagram of a configurable device with independently configurable frames. 
         FIG. 6  is a diagram illustrating use of checking modules in a configurable device. 
         FIGS. 7A-B  are diagrams of PUF circuits. 
         FIG. 8  is a block diagram of a system that includes a license server. 
         FIG. 9  is a diagram illustrating a PUF module that uses public key encryption. 
         FIG. 10  is a block diagram using a license server in conjunction with a PUF module shown in  FIG. 9 . 
     
    
    
     DESCRIPTION 
     Referring to  FIG. 2 , a field programmable gate array (FPGA)  210 , which is an example of a configurable electronic device that can be protected using the techniques described below, makes use of a physically unclonable function (PUF) circuit  225 . As is described more fully below, the PUF circuit provides a digital value that is dependent on specific characteristics the particular FPGA but that is essentially unpredictable and not discoverable through examination of the device. For a set of devices that include a PUF circuit that is fabricated according to a same design (e.g., with the same circuit mask), the value produced by the circuit varies among those devices in essentially and unpredictable manner. 
     A PUF module  220 , which incorporates the PUF circuit  225 , accepts a digital challenge input (C) and based on the challenge input and physical characteristics of the PUF circuit produces the digital response (R). In general the challenge and response are multi-bit quantities (for example, 160 bits long). 
     Prior to deploying the FPGA, in an enrollment procedure, a party wishing to securely distribute configuration data for one or more FPGAs chooses a challenge input (C) and records the associated response (R) for each FPGA that will be deployed and to which configuration data will be sent. Optionally, the party records multiple challenge-response pairs for each FPGA device to be deployed. 
     Configuration data  160  for distribution and field programming into the FPGA is encrypted using an encryptor  170  according to a key  125 , which is generally chosen by the party distributing the configuration data and kept secret. By encrypting the configuration data, unauthorized parties gaining access to the encrypted configuration data  180  cannot without great difficulty (i.e., by breaking the encryption) access the information encoded by the configuration data. 
     To load the configuration data, a particular FPGA internally reconstructs the key needed to decrypt the configuration data without disclosing the key outside the FPGA device and without storing the key in a non-volatile storage, which might be comprised. In order to enable the FPGA to reconstruct the key, the party enrolling the FPGA combines the key and the response from the PUF circuit, which depends on the challenge input in an unpredictable way, to produce an access code. The access code is provided to the FPGA in the field. The PUF response to the same challenge can then be combined in the field with the access code to determine the needed key. In this example, the key and the response are combined according to a bitwise exclusive OR operation. The PUF module  220  is configured such that when deployed in the field, the response (R) for a particular challenge cannot be determined from the device. Various approaches to preventing such access to the response for a particular challenge are described below. The access code can be made publicly available without compromising the PUF response and therefore without compromising the encryption key. 
     In the field, the encrypted configuration data  180 , the challenge value  230  used during enrollment of the FPGA, and the computed access code  235  are made available to the party wishing to configure the device. Note that the access code is specific to the device while the challenge and the encrypted configuration data may be general to a number of device. Therefore, for example, the challenge may be distributed along with the encrypted configuration data and the access code may be distributed with the device. 
     The PUF module  220  is configured to accept the challenge value  230  and the access code  235 , and compute a combination of the internally generated PUF response (R) and the accepted access code (A) that allows internal reconstruction of the key used to encrypt the configuration data. This computed key is not made available outside the device and therefore does not compromise the security of the configuration data. Internal to the FPGA  210 , the computed key is provide to a decryptor  140 . The configuration module  145  makes use of the decryptor  140  to decrypt the encrypted configuration data  180  before it is loaded into the configurable logic  150 . The configurable logic implements logical functions using circuit elements specified by the configuration data. In this version of the approach, the decryptor  140  and the PUF module  220  make use of dedicated circuitry on the FPGA that is not necessarily configurable. The key provided to the decryptor is a volatile key in that the key value is lost when the FPGA is not powered, When the FPGA is once again powered, the key can be regenerated from the access code and challenge as needed. 
     In one example of this approach, the access code  235  is stored in a static memory (e.g., a ROM memory) external to the FPGA. The encrypted configuration data is provided on a memory, such as a dynamic RAM along with the challenge. 
     Referring to  FIG. 3A , one version of the PUF module  220 , includes a data path that provides the challenge value to the PUF circuit  225 . The response (R) is provided to an output interface on the FPGA through a fusible link  325  so that it is accessible during enrollment of the FPGA. After enrollment and before deployment in the field, the fusible link  325  is opened (“blown”) so that the response to any particular challenge can no longer be obtained from the PUF module. Internal to the PUF module, a bitwise exclusive OR element  330  accepts the output of the PUF circuit and the access code to compute the exclusive or of those value that are used as a key during loading of the encrypted configuration data. 
     Referring to  FIG. 3B , another design of the PUF module  320  uses another approach to prevent output of the PUF response for any chosen challenge value, but that allows later repeated enrollment of the same device. The PUF module  320  makes use of a prechallenge value (PC) during enrollment. Internal to the PUF module  320 , the challenge value (C) is computed for the challenge by a known but not easily invertible hash function  338 , such as the Secure Hash Algorithm SHA-1. Because the hash function is known to the party enrolling the FPGA, the challenge value is also determined externally to the FPGA by that party. During enrollment, the internally computed challenge value passes to the PUF circuit  225  through a selector  334 . The selector is controlled by a control signal RorS, which is set to 1 during enrollment and to 0 in the field. Only when RtoS is 1, the PUF response is passed through a buffer  336  to the output; when RtoS is 0, the PUF response is not provided to an output port of the FPGA. The prechallenge value is kept secret (or discarded) and the computed challenge value (C) is provided with the encrypted configuration data as described above. The access code is computed from the response and the desired key also as described above. In the field, in order to provide the challenge value to the PUF circuit, the RorS value must be set to 0, and therefore the PUF response is not accessible outside the PUF module. The hash function  338  may be kept secret. Even if know, the function is not easily inverted and therefore the prechallenge needed to generate the challenge value cannot easily be determined. Therefore the response value for the particular challenge cannot easily be determined by a party in the field, and therefore the decryption key remains secure. 
     An optional feature of the PUF module  320  is the use of an error correction code (ECC) module  332 . In versions of the PUF circuit  225  which do not necessarily provide exactly the same response whenever a particular challenge is provided (for example, due to relatively small variations causes by environmental conditions such as temperature), the ECC module is used to “correct” any differences between the PUF response obtained in the field and the response used during enrollment. During enrollment, the response is used to determine redundant information, such as a BCH syndrome of the response. This syndrome is recorded along with the access code and provided to the FPGA in the field. The syndrome value is passed to the PUF module  320  and to the ECC module  332  so that even if the PUF response differs from the enrollment response in a limited number of bit positions, the enrollment response is provided at the output of the ECC module  332 . Although the syndrome may provide some information about the possible values the enrollment response may have had, this information is not sufficient to reconstruct the response and thereby compromise the key. 
     Another approach to implementing error correction uses a voting approach. This alternative can be preferable because of the relative simplicity of implementing the error correction on an FPGA. In this approach, rather that using a single challenge-access code pair to generate a particular key, multiple challenge-access code pairs are used for the same key. Based on the design of the PUF circuit, for each different challenge input, the difference between the enrollment response and the in-the-field response is relatively independent. That is, for a the multi-bit response, the errors can be viewed as being distributed independently over the various bits of the response. Therefore, the key generated with different challenge-access code pairs is expected to have errors in somewhat independent bit positions. Each bit position of the key is considered independently and a final key determined by a majority vote of that bit position for the various input pairs. Note that if for any input pair there is a probability of error of p, then with N pairs and a key of length M the probability that the majority vote key is correct is approximately (1-Mp N/2 ), which can be make small by increasing the number of pairs, N. 
     Referring to  FIG. 4 , in another version of the approach, the challenge value  230  and the access code  125  are recorded in a non-volatile storage,  430  and  435  respectively, on a FPGA  410  itself. An array of (challenge, access code) pairs can be stored in the FPGA, each for internal generation of a different key. Examples of such a non-volatile storage are register of fusible links and EPROM registers. Although the values of the challenge and access code may be compromised by examination of the FPGA, as in the previous examples these values are not sufficient to determine the PUF response to the challenge and thereby the key value remains secure. 
     Referring to  FIG. 5 , in another example, an FPGA  510  includes configurable logic  550  that includes a number of separately configurable frames  555 . Initially, a loader design  580  is loaded into a first frame  555  of the FPGA. This loader design configures the functionality of the decryptor  540  and PUF module  520  into the frame bank Once configured, these modules provide the functionality of the PUF module  320  and decryptor  140  that use dedicated circuitry in other examples. Specifically, the functionality implemented in the first frame is used to load and decrypt the encrypted configuration data  180 , which is loaded into the remaining frames of the FPGA. An example of a commercially available devices that may support this feature include the Xilinx Virtex II™ family of devices that support the internal reconfiguration access port (ICAP) interface. 
     A number of other alternative approaches to maintaining the secrecy of the response to a particular challenge may be used in an approach such as that described above. For example, although described in terms of a symmetric key approach in which the same key is used for encryption and decryption, a public-private key pair can be generated and the access code computed by the party enrolling the FPGA so that the PUF module can internally generate the private key. One use of such a public key approach is that the public key for an FPGA can be made publicly available so that any party can securely provide information to the FPGA. One such use may be to encrypt the configuration data decryption key using the public key for the FPGA, thereby allowing only that FPGA to determine the decryption key and load the configuration data. Many other uses of the such a public-private key pair are possible using well known secure communication approaches. 
     Referring to  FIG. 6 , in FPGAs  610  that do not include special purpose PUF modules or decryptors, and do not allow loading of such modules in separate frames of the configurable logic to be used to load the main portion of the logic configuration, PUF circuits can still be used to check that the configuration data is loaded and in use on an authorized FPGA. In general, in such an approach a PUF circuit  225  is implemented using a portion of the configurable logic  650  of the FPGA  610 . A generator module  670 , which is logically coupled to the PUF circuit and to input and output interfaces of the FPGA, is also loaded into the configurable logic. During an enrollment phase, a challenge  230  is passed to the PUF generator module via the generator module  670 , and a corresponding response  235  is passed back from the PUF circuit through the generator module. Prior to deploying the configuration data for the FPGA, the response is incorporated into the configuration data. In the field, functions implemented in the configurable logic provide the same challenge as used in enrollment to the PUF circuit and check that the response is the same or suitably similar to the response provided through the generator module during enrollment. If the response in the field does not match, then functionality of the configured FPGA is disabled. Such a lack of a match typically occurs when the configuration data is loaded on a different FPGA than the one for which it was authorized and customized. 
     Continuing to refer to  FIG. 6 , a logic design  630  includes a design for functional logic as well as a number of additional components that are associated with the checking function. The logic design is specified, for example, using a Verilog specification, which identifies the logical components of the design but not necessarily the detailed layout of the design onto the configurable logic of the FPGA. The logic design  630  implements a PUF circuit  225 , generator  670 , and checker logic  660 , which is described more fully below. The logic design  630  also embeds a challenge value  230 , which will be used as input to the PUF circuit. The PUF response to the challenge is not yet known at this point, and a null (e.g., all zeros) response value  232  is also embedded in the logic design, for example, at a particular address in an addressable storage area specified in the logic design  630 . This logic design is passed through a compiler  635  to produce the configuration data  660 , which includes the challenge  230  and null response  232 . In the course of the compilation process, the portions of the configure logic that hold the bit values of the challenge and the null response are distributed to logic elements such that, in general, examination of only the configuration data  660  does not easily yield the challenge value  230  or the circuit locations used to store the bits of the null response value  232 . 
     During a enrollment of the FPGA  610 , the configuration data  660  is used to configure the configurable logic  650  of the FPGA. The challenge value  230  is applied to the FPGA. Internally the portion of the circuitry implementing the generator module  670  accepts the challenge value and passes it to the circuitry implementing the PUF circuit and passes back the response  235 . 
     The response  235  is used by a patcher  650  to replace the null values of the response in the configuration data  660  with the particular response  235  for the FPGA being enrolled. The result is customized configuration data  680 , which includes both the challenge value  230  and the corresponding response  235 . The patcher uses information from the original logic design  630  and/or an output of the compiler  635  to identify the portion of the configuration data that needed to be modified in order to embed the response value into the configuration data. Note that this results in different configuration data  680  being used for each FPGA  610  that is fielded, with the vast majority of the configuration data being common and only a small amount of the difference corresponding to the different response values. Optionally, the patcher  665  introduces other differences in each customized configuration data  680  in order to obfuscate the location of the response value  235 , for example, should a party with access to a number of different instances of the customized configuration data compare the instances to identify which parts vary from device to device. Note that such comparison of instances does not yield the challenge value  230 , which in this example is common to all the instances. 
     In field use, the customized configuration data  680  is used to configure the configurable logic  650  of the FPGA  610 . The configurable logic implements desired functional logic  640  of the device, as well as a checker function  660 . The checker function has embedded in it the challenge value  230 , and can access the patched response value  235 . The checker function  660  is configured to access the PUF circuit  225  in operation of the device, providing the challenge value and receiving the field-computed response value. The field computed response value is compared to the patched response value  235  by the checker function. In operation of the device, the checker function is invoked, for example, during an initialization phase or preferably, from time to time during operation of the device. If the checker function finds that the field-computed response does not match the enrollment response that is patched into the configuration data, the checker function causes the functional logic  640  of the design to be disabled. For example, required volatile memory in the device can be cleared or corrupted causing malfunction. 
     The checker function  660  is incorporated into the functional logic  640  in such a way that it forms an integrated portion of the logic. This makes it more difficult for a party to analyze the customized configuration data  680  and then modify the configuration data to disable the checker function. Furthermore, multiple instances of the checker function can be implemented in the design so that a party would have to identify all the instances and disable them all. As another alternative, multiple challenge-response pairs can be used, and each challenge used by a different checker function incorporated into the design. 
     In the example above, the generator module  670  is present in the customized configuration data  680  that is deployed in the field. As a further feature that can make compromising security more difficult, the generator module  670  is functionally disabled or entirely absent from the customized configuration data  680 . In this way, should an adversary party discover the challenge value and identify the appropriate circuit locations that should hold the response values, that party would have to re-implement the generator function to obtain the response needed for a particular FPGA. 
     Referring to  FIG. 7A , one approach to designing the PUF circuit for the approaches described above makes use of a delay module  710  whose delay depends on the binary values of the challenge at different bit positions. Each of the first n−1 bit positions of the challenge control whether a corresponding two input of a delay element  715  pass signals straight through or criss-cross to its two outputs. The final bit position of the challenge controls a selector that chooses either the top or the bottom output of the last delay element  715 . With the same input passed to the two inputs of the first delay element  715 , the delay from that input to the output of the selector  717  is dependent on the challenge input. The delay module  710  is put in a feedback path that causes oscillation at a period that depends on the delay through the delay module. A period measurement module  730  determines the response based on the period, for example, counting the duration of a set number of periods of oscillation. Referring to  FIG. 7B , another approach makes use of the delay module  710  to generate two different delay paths from the input to the output. The two outputs are passed to an arbiter  737 , which outputs 1 if the top signal rises first and 0 if the bottom signal rises first. Each output of the arbiter generates one bit of the response stored in a shift register. The challenge input C is used as a seed to a finite state sequence generator that outputs a series of derived challenges that are passed to the delay module to generate each bit of the response in turn. 
     Referring to  FIG. 8 , one or more approaches of the types described above are used in an application which licenses or other accounted-for authorizations for use of logic designs are provided to one or more system integrators  820 . For example, the system integrator may use an FPGA that is configured in a system  850  to use a logic design that is licensed from another party. The system integrator receives authorization to use that logic design on an FPGA-by-FPGA basis, thereby, for example, enabling payment of per-FPGA royalties to the party providing the logic design. The logic design is protected so that the system integrator cannot circumvent the licensing requirement and deploy more copies of the configured FPGA than authorized. 
     In the example shown in  FIG. 8 , in an enrollment phase, which is prior to distribution of the FPGAs to the system integrator, a party such as the manufacturer of the FPGA or an intermediate distributor enrolls each FPGA and stores a device identifications and one or more associated challenge-response pairs  818  for each FPGA. This enrollment data populates a database  815  that is used by a license server  830 . The license server is accessed by the system integrator in order to obtain the data needed to enable each FPGA. 
     The enrolled FPGAs  210  are distributed to one or more system integrators. A system integrator receives encrypted configuration data for the FPGA, with the configuration data being decryptable using a key know to the license server. For each FPGA that the system integrator wants to have authorized to use the configuration data, the system integrator sends an identification of the FPGA to the license server, along with an identification of the configuration data. The license server uses the FPGA identification to find a challenge-response pair that is particular to that FPGA. It also uses the identification of the configuration data to find the key needed to decrypt the configuration data. The license server then combines the response and the key (for example, according to a bitwise exclusive or) to determine an access code that will be passed to the FPGA for use of the configuration data. The license server passes the challenge and the computed access code back to the system integrator, and the system integrator embeds the access code in the system that will be deployed, for example, in a non-volatile storage on the FPGA (e.g., fuses) or in an off-chip storage  855  (e.g., PROM). The license server keeps a record of the access codes it has provided to the system integrator and stores accounting data  855  which is later provided to the party providing configuration data. 
     In a related alternative approach, it is not necessary for the license server to have access to the key needed to decrypt configuration data. In this approach, the manufacturer knows the key and the enrollment data includes a challenge-access code pair. Furthermore, the manufacturer may generate multiple challenge-access code pairs for each FPGA, each for a different key. Each key can then be provided to a different configuration data provider by the manufacturer. 
     Referring to  FIG. 9  another approach to generating access codes involves public key encryption. In this approach, a trusted party, such as a license server, generates a private-public key pair (PrivK-PubK). An FPGA  1010  (not shown in  FIG. 9 ) includes an alternative PUF module  920  that receives the public key (PubK) and optionally an additional challenge (C). The input to the PUF circuit  225  is the public key, or alternatively a non-invertible function of the additional challenge and the public key. (Even without an optional challenge, the public key may be modified by a non-invertible function, for example, to reduce the number of bits for the PUF circuit input). The output of the PUF circuit (R) is encrypted in a public key encryption module  915  before it is provided outside the FPGA. Therefore, only a party that has access to the private key corresponding to the public key used can decrypt the FPGA output to determine the PUF response. 
     Referring to  FIG. 10 , a system integrator  1020  configuring a system that incorporates an FPGA  1010  that uses the PUF module  920  receives the public key (PubK) from a license server  1030 . The system integrator optionally adds its own challenge (C) and obtains the encrypted response from the FPGA. The encrypted response is passed back to the license server, where it is decrypted using the private key known to the license server. Having determined the response, and knowing the key (K) needed to decrypt the configuration data for the FPGA, the license server computes the needed access code (A) and passes the access code back to the system integrator. The system integrator then integrates the access code, and if needed its own challenge, into the system being configured. The license server keeps track of the number of access codes that were computed and stores accounting data as described above. 
     Other approaches that generate challenge response pairs, for example, based on delay characteristics or other circuit characteristics can also be used. Techniques that can be used in or combined with the approaches described above can be found in US Application Publication US2003/0204743A1, which is incorporated herein by reference. 
     Approaches described above are applicable to various types of configurable devices. For example, the configuration data can include one or more of logic configuration data and instructions used in operating the device. The instructions can include controller instructions, micro-code, machine instructions for a programmable processor (e.g., for an x86 instruction set architecture), instructions for a virtual machine or processor (e.g., Java instructions), or instructions for a software interpreter. Furthermore, the encrypted information can include content that is to be presented to a user rather than or in addition to logic configuration data or instructions. One example is encryption of audio or video content data for presentation on or using a device, but that cannot be presented on or using another similar device that does not have the same PUF response and volatile key internally. 
     It is to be understood that the foregoing description is intended to illustrate and not to limit the scope of the invention, which is defined by the scope of the appended claims. Other embodiments are within the scope of the following claims.