A variable method for generating identifiers for a batch of assets in a computing environment

Abstract

A variable-capacitance method for generating a fingerprint of a computing environment based on asset parameters associated with components of the computing environment. The asset parameters are grouped into multiple subsets based on component characteristics. A share is generated for each asset parameter of that category, resulting in multiple shares. A secret-sharing algorithm is applied to the subsets to generate multiple candidate identifiers corresponding to the multiple share subsets. Candidate identifiers are selected from the multiple candidate identifiers as the final identifier for each category, based at least in part on the frequency of occurrence of the candidate identifiers. The final identifiers are combined to form a fingerprint corresponding to the computing environment, wherein the fingerprint provides verification of the multiple components without requiring individual verification of any of the multiple shares.

Description

Technical Field

[0001] This disclosure generally relates to generating identifiers for multiple batches of assets. More specifically, this disclosure relates to a variable method for generating identifiers for a batch of assets in a computing environment using a secret-sharing scheme. Background Technology

[0002] Many protection technologies for computing environments, such as personal computer (PC) systems, require mechanisms to robustly identify the PC on which applications run. This is typically achieved by reading identifiers from various assets of the system, such as hardware components integrated into the computer (motherboard parameters, BIOS, MAC address, hard drive, CD / DVD player, graphics card, I / O controller). These identifiers are then combined into a single identifier, i.e., the system's "fingerprint." For example, a simple way to derive the system's fingerprint is to apply an XOR operation to all device identifiers.

[0003] A basic fingerprinting algorithm collects assets from the system and combines them in a certain way to produce a smaller value called a fingerprint. This fingerprint serves as an identifier for the device: each time the same algorithm is run, it should deterministically produce the same fingerprint. However, the identifier may or may not be unique; this is a quality factor of the asset.

[0004] However, in many cases, the set of assets subject to fingerprinting algorithms changes. This could occur for malicious purposes (e.g., a deliberate attempt to alter the identity of computing components), but most often, it's simply the result of a user legitimately updating the software or hardware on their system by updating the operating system, swapping out a hard drive, or making other acceptable changes to the computing components. If any asset, such as the computing component, changes, the underlying fingerprinting algorithm will cause the fingerprint of the computation to change. Depending on the use case, this is often undesirable.

[0005] When computer components or other assets change, such as due to replacement or repair, the methods used to determine system identifiers need to adapt to acceptable changes to component identifiers. One way to support component updates is by allowing some component identifiers to change while still generating the same system identifier. A known way to achieve this is by recording unique component identifiers during the initialization phase, comparing the recorded identifiers with the actual identifiers during the identifier calculation phase, and using the recorded identifiers to calculate the system fingerprint if sufficient matches exist.

[0006] Similar methods exist for deriving a system's fingerprint from a set of contribution information fragments that may change over time. Although based on different contribution information, such methods also need to adapt to changes in the contribution information without altering the calculated fingerprint. As before, if there is sufficient matching between the actual information and the recorded information, the contribution information can be recorded and used as an identifier.

[0007] One problem with such methods is that the comparison between the recorded identifier and the retrieved parameters is vulnerable to attacks. The presence of the recorded device identifier is a key enabler for these attacks. Therefore, it is desirable to provide a method for generating system fingerprints that is tolerant of changes in the computing environment while resisting malicious attacks.

[0008] One approach, known as "M-fingerprint in N," attempts to solve the problem of combining information about assets (e.g., computing elements) on adversarial and volatile computing systems to generate a fingerprint of the system. The goal is to allow the fingerprint to remain the same even if some changes occur in the assets (such as computing elements) up to a predetermined threshold. Furthermore, this should be done without storing the expected asset parameters, as this would provide an easy attack vector.

[0009] However, if too many asset changes are allowed—that is, the threshold is too high—and no changes are found in the resulting fingerprint, the results can be problematic. For example, in the extreme case where all assets can change, the result is that any combination of assets will necessarily produce the same fingerprint, meaning the fingerprint is not actually an identifier at all. In the "M-fingerprint algorithm in N," the algorithm will produce the same result—the same fingerprint—as long as M or more of the N assets remain the same. In such a method, all assets are treated equally. It doesn't matter which assets match or which assets change, as long as the threshold is met.

[0010] As stated, the value M is a threshold—if fewer than M assets match, an incorrect fingerprint will be generated (with an overwhelming probability), and if M or more assets match, a correct fingerprint will be generated. This can be generalized to some extent by allowing for a looser threshold. For example, only the negative case can be supported—if fewer than M assets match, an incorrect fingerprint will be generated. Conversely, most, but not all, cases with M or more asset matches will generate a correct fingerprint (of course, all N asset matches will generate a correct fingerprint). As another example, only the positive case can be supported—if M or more assets match, a correct fingerprint is guaranteed, while allowing most cases with fewer than M asset matches to generate incorrect fingerprints. Such looseness may provide performance trade-offs.

[0011] U.S. Published Patent Application No. 2014 / 0007252 discloses a tolerance-variant method of generating an identifier of a batch of assets associated with a computing environment using an M-out-of-N fingerprinting algorithm. Each of the assets has identification asset parameters associated therewith. The asset parameters of a batch of assets are retrieved and shares corresponding to each of the asset parameters are generated to provide a plurality of shares. A "share" is known to be used in a "secret sharing" method, which is a method for distributing a secret among a group of participants, where each of the participants is assigned a share or a portion of the secret. The secret can be reconstructed only when a sufficient number of shares are combined. An individual share is useless by itself.

[0012] In the method disclosed in U.S. Published Patent Application No. 2014 / 0007252, a secret sharing algorithm is applied to multiple subsets of the plurality of shares to derive multiple candidate identifiers (fingerprints); the number of the subsets is determined according to a tolerance threshold of the difference of the asset parameters compared to the original asset parameters of the computing environment. The most common candidate identifier value is determined and designated as the final identifier of the batch of assets, i.e., the fingerprint. For example, the final identifier can be used to determine whether a software application can be effectively executed on a computing platform that is a batch of assets. The secret sharing algorithm can be an (M-k, N) secret sharing algorithm, where N is the number of the plurality of shares, M is the number of shares having correct values (thus M < N), and k is a predetermined constant. The tolerance threshold is equal to N-M. However, in the case of M = 1, i.e., only 1 asset in the set remains the same, the method fails. In addition, when N is large, for example, greater than 10 in one example, the method may exhibit performance problems. These limitations render the method discussed above not programmatic in many implementations. SUMMARY OF THE INVENTION

[0013] One implementation includes a tolerance-variant method of generating a fingerprint of a computing environment including a plurality of components, each of the components having identification asset parameters associated therewith, the method including: retrieving the identification asset parameters of each of the components; grouping the identification asset parameters into a plurality of subsets based on the characteristics of the components corresponding to the identification asset parameters, each category having at least one identification asset parameter; for each subset of the identification asset parameters: generating shares corresponding to each of the identification asset parameters of the category to produce a plurality of shares; modifying the shares using the identification asset parameters; applying a secret sharing algorithm to the plurality of subsets of the shares to generate a plurality of candidate identifiers corresponding to the plurality of subsets of the shares; and selecting, at least in part based on the frequency of occurrence of the candidate identifiers, the candidate identifier as the final identifier of the category; and combining the final identifiers into a fingerprint corresponding to the computing environment, wherein the fingerprint is configured to provide verification of the plurality of components without requiring individual verification of any of the plurality of shares.

[0014] Another implementation includes a system for generating a variable fingerprint of a computing environment comprising multiple components, each of which has associated asset parameters. The system includes: at least one computer hardware processor; at least one memory storing instructions that, when executed by the at least one processor, cause the at least one processor to: retrieve the asset parameters of each of the components; group the asset parameters into multiple subsets based on characteristics of the components corresponding to the asset parameters, each category having at least one asset parameter; for each subset of asset parameters: generate a share corresponding to each asset parameter of that category to produce multiple shares; modify the shares using the asset parameters; apply a secret-sharing algorithm to the multiple subsets of shares to generate multiple candidate identifiers corresponding to the multiple subsets of shares; and select the candidate identifiers from the multiple candidate identifiers as the final identifier for that category, at least in part based on the frequency of occurrence of the candidate identifiers; and combine the final identifiers into a fingerprint corresponding to the computing environment, wherein the fingerprint is configured to provide verification of the multiple components without requiring individual verification of any of the multiple shares.

[0015] Another implementation includes a non-transient computer-readable medium having computer-readable instructions stored therein for generating a variable fingerprint of a computing environment comprising multiple components, each of which has associated asset parameters. When executed by at least one computer hardware processor, the instructions cause the at least one computer hardware processor to: retrieve the asset parameters of each of the components; group the asset parameters into multiple subsets based on characteristics of the components corresponding to the asset parameters, each category having at least one asset parameter; for each subset of asset parameters: generate a share corresponding to each asset parameter of that category, to produce multiple shares; modify the shares using the asset parameters; apply a secret-sharing algorithm to the multiple subsets of shares to generate multiple candidate identifiers corresponding to the multiple subsets of shares; and select, at least in part, the candidate identifiers as the final identifier for that category based on the frequency of occurrence of the candidate identifiers; and combine the final identifiers into a fingerprint corresponding to the computing environment, wherein the fingerprint is configured to provide verification of multiple components without requiring individual verification of any of the multiple shares. Attached Figure Description

[0016] The implementation will now be described by way of example only, with reference to the accompanying drawings.

[0017] Figure 1 It is a flowchart based on the implementation method.

[0018] Figure 2 - 3 is a diagram based on the implemented fingerprinting method;

[0019] Figure 4is a diagram of an implemented share encryption process; and

[0020] Figure 5 is a diagram of an implemented share decryption process.

[0021] Figure 6 is a flowchart of an implemented sharing algorithm.

[0022] Figure 7 is a flowchart of an implemented process for calculating a fingerprint at runtime. Detailed Implementation Manner

[0023] The disclosed implementation provides a secure and adaptable method for creating a fingerprint of a computing environment from a set of N shares, even when only M shares (M < N) from the set have correct values. The method can use all subsets of M - 1 shares from the N shares to generate candidate identifiers.

[0024] The implementation can be applicable to using any (M - 1, N)-secret sharing scheme. The method can generally be used to generate fingerprints of any batch of assets, and asset parameters can be assigned or determined as identifiers for the assets. As used herein, an "asset" can be a component, e.g., any data, application, device, node, or other component of a computing environment. Components generally include hardware (e.g., servers and switches), software (e.g., mission-critical applications and support systems), and confidential information. The terms "computing environment", "computer environment", and "computer system" are used interchangeably herein and are intended to cover single computers and other devices that include a processor, distributed computing systems, their components, data stored or otherwise associated therewith, and data associated with users of such computer systems, additional or accessible peripheral devices, software applications, and operating systems, and combinations thereof. As used herein, "asset parameter" means an assigned or determined parameter that is restricted in terms of the occurrence of a given class of components, situations, or regions. An asset parameter can be unique or can at least uniquely identify a component when the parameter is assigned or determined. An asset parameter can be expressed as, for example, a number, symbol, number and string, or function.

[0025] An example system in which this implementation can be used is a computer system with multiple peripheral devices as components; each peripheral device has a more or less unique device identifier, such as a serial number or other assigned asset parameter. Typically, such device identifiers are assigned to the device by the manufacturer. The computer system can be a network of embedded microcontrollers, where each microcontroller, as a component, has a unique identifier. This configuration is often found in more complex systems (e.g., aircraft, automobiles, industrial machines) that are repaired by replacing the entire microcontroller module. In such systems, it may be beneficial to link the controller's firmware to a specific networked device. Data sources associated with or stored on a computer system can also be considered assets. Examples include contact lists, user preferences, names, addresses, dates, or other parameters that do not change frequently. Asset parameters can be obtained by applying a function to parameters associated with one or more assets. For example, asset parameters might be generated by a function that takes as input parameters associated with components such as computer memory, a specific application, or a batch of files. Some asset parameters may also require user input (e.g., passwords, insertion of a removable data source, or fingerprint scanning) to become available for processing by the methods described herein.

[0026] Public implementations can be applied to node locking or other fingerprinting applications. Node locking is relevant to a wide range of applications across different domains. For example, it can be used on personal computers (PCs), embedded devices, and other computing platforms. One implementation is a form of fingerprinting application that allows node locking. Node locking is a feature that restricts the execution of a particular application on a single or specific set of computing platforms (e.g., PCs, set-top boxes, game consoles, or mobile phones). If an attempt is made to execute the application on a different computing platform, the application will either fail to execute or result in execution of a different operation compared to the operation performed on the platform(s) it is intended to execute on.

[0027] When used in conjunction with node locking, an application can link to a set of asset parameters obtained from components within a computer platform. This means the application has a personalization phase, in which it is configured to execute on the intended computer platform. During a later phase, the application collects asset parameters from components within the computer platform on which it is executing to derive a system identifier (fingerprint). The system identifier can be used for a wide range of functions that the application supports only on that specific computer platform. The implementation allows one or more of the asset parameters collected in the later phase to differ from the original asset parameters used in personalizing the application, while still returning a valid fingerprint that leads to the correct execution of the application.

[0028] In practice, this implementation converts a set of N shares into an identifier. The method uses all subsets of M-1 shares from the N shares to generate candidate identifiers using an (M-1, N) secret-sharing algorithm. Whichever candidate identifier appears most frequently among the generated candidates can be used as the final identifier. The variant method terminates once a candidate identifier with a given value appears more than M times. Note that for a valid identifier to be generated by this method, at least M shares must be correct; in this case, candidate identifiers will appear at least... M Second-rate.

[0029] like Figure 1 As shown, one implementation is a method of identifying or verifying a batch of assets (such as components of a computer system) for the execution of an application (such as node locking) using a fingerprinting method. Numerous asset parameters are associated with the batch of assets to be verified. Asset parameters can be any sufficiently unique parameter, such as a component's serial number or a otherwise assigned string associated with the asset. While this method is described in relation to verifying a batch of assets for the execution of a software application on a computer platform, it will be understood that this method can be used to verify or confirm the identity of a batch of assets to perform any operation on or in conjunction with the batch of assets, and where variations between the original assets in the batch are permitted. The correct system identifier is returned even if a permissible number of asset parameters have changed since the application was first verified for execution on the batch of assets. The extent of the changes, such as the permissible number of parameters, is determined by a tolerance threshold, which may be set by the application distributor or other settings.

[0030] The method begins with a first phase of fingerprint initialization, which involves retrieving or otherwise collecting asset parameters for a batch of assets at point 100. Then, at point 102, shares corresponding to each asset parameter are generated to provide multiple shares. An example of the share and sharing algorithm used with the implementation is illustrated in more detail below. Each share may correspond to an asset parameter, or asset parameters may be combined or otherwise processed to create each share, as described in more detail below. Then, at point 104, the shares are encrypted using the corresponding asset parameters. An example of the encryption method used with the implementation is illustrated in more detail below.

[0031] In the second stage of fingerprint computation, at point 106, asset parameters are retrieved and used to decrypt shares. Only correct asset parameters will result in a correct share. Then, at point 108, a secret-sharing algorithm is applied to a subset of multiple shares to derive multiple candidate identifiers, each with a candidate identifier value. The number of subsets is determined based on a tolerance threshold, which relates to acceptable differences in asset parameters compared to the initial asset parameters of a batch of assets. In other words, the tolerance threshold is a measure of the amount of variation of the application or other operation against its originally verified asset parameters, such variation being deemed acceptable by the application creator or others. The most prevalent candidate identifier value is determined, and then at point 110, the most prevalent candidate identifier value is selected as the final identifier. The final identifier is used for relevant determinations, such as determining whether the application can be effectively executed on a batch of assets.

[0032] The implementation of fingerprint calculation according to the present invention is as follows: Figure 2 As shown in the diagram. The method begins at point 202 by first collecting asset parameters about the target device and using them to decrypt shares in a manner described in detail below. Some of the asset parameters and associated shares may have values ​​different from the same asset parameters used during application personalization or initialization. This will result in incorrect corresponding shares. At point 204, N decrypted shares are stored in memory. At point 206, all possible subsets of M-1 shares are generated from all recorded shares. For each of the 208 subsets, a candidate identifier is computed at position 210 using an (M-1, N)-secret-sharing algorithm. Depending on the application and functional requirements, any suitable (M-1, N)-secret-sharing algorithm can be used. Well-known (M-1, N)-secret-sharing algorithms include, for example, Shamir's and Blakley's secret-sharing algorithms. Shamir's scheme is disclosed in Shamir, Adi (1979) "How to Share a Secret" (Communications of the ACM, 22 (11): 612–613).

[0033] For each of the candidate identifiers 212 generated by the secret sharing module, the candidate identifier "ID" and the number of times it was generated (as output "Freq") are recorded in a storage device at 214, for example, using a suitable indexing mechanism to efficiently retrieve and update the frequency "Freq" of occurrence of a given candidate identifier "ID". This is after processing all subsets to generate... Following ID212, at position 216, the stored {ID, Freq} data pairs are processed to find the candidate identifier with the highest frequency, and this candidate identifier is selected as the final identifier, i.e., the fingerprint. Among the candidate identifiers, the frequency of the final identifier is an indicator of the error rate in the asset parameters. If made available for application, it can be used for diagnostics, recovery, or other purposes.

[0034] Another implementation of the fingerprint method is in Figure 3 As shown in the diagram. The method again begins at 302 by first retrieving, reading, or otherwise obtaining asset parameters from the system's assets, using them to decrypt shares, and at 304 storing N shares in memory. At 306, all possible subsets of M-1 shares are generated from all recorded shares. Processing continues at 310... At subset 308, candidate identifier values ​​are monitored as they are placed in storage 312. At 314, the first candidate identifier value that appears M times is selected as the final identifier, and the method terminates. This implementation can reduce processing time / resources, but there is no indication of the error rate in the asset parameters, and the time of termination of the process can be used as an attack point.

[0035] As described above, shares corresponding to asset parameters are generated. However, in most embodiments, share values ​​will be independent of asset parameters. To correctly associate shares with asset parameters so that incorrect asset parameters will result in incorrect shares, the shares must be modified (encrypted) during the initialization phase. This can be achieved by transferring the asset parameters to another application that generates and encrypts the shares (possibly using another verification mechanism, such as a personal contact or telephone conversation) and returns the encrypted shares. Alternatively, the installation may have a built-in initialization component that is disabled after the initialization process is complete.

[0036] For example, a diagram illustrating the application's initialization process is shown in Figure 4 As shown in the diagram. At 402, the initialization function running on the target computer first obtains an appropriate number of parameters by reading the asset parameters from asset 1 to N. In this embodiment, the asset parameters are then normalized at 404. Normalization can be achieved, for example, by generating a normalized set of asset parameters using a hash function. To achieve this.

[0037] During initialization, N shares The share is generated at position 406. As those skilled in the art will understand, the method used to generate or construct the share depends on the secret-sharing method used. Some examples are illustrated below again. If Shamir's secret-sharing algorithm is used, a polynomial with random coefficients is constructed, where the expected identifier is the constant coefficient of the polynomial. The degree of the polynomial depends on M, as determined by design and security considerations. The share is then determined by evaluating the polynomial of the selected input. A function is used... Each share S i With the corresponding asset parameter D i Combining. Function E() can be viewed as using asset parameter D i Share S i Encryption and generation of ciphertext constant C i A simple implementation of E() is an XOR operation. At 408, the final initialization step will ciphertext constants. It is embedded into the application as initialization information.

[0038] During application verification, the decryption of shares is implemented in Figure 5 As shown in the diagram, the equipment parameters are retrieved again at point 502 and standardized at point 504 to generate a standardized set of asset parameters. The initialization information in the application contains ciphertext constants. At position 506, use the function. Each ciphertext constant C i With the corresponding asset parameter D i Combination. Function D() can be viewed as using asset parameters D i For the ciphertext constant C i Decryption and generation of share S i A simple implementation of D() is an XOR operation. The personalized application then calculates the final identifier for a batch of assets at position 508 (as described above) using shares.

[0039] This allows for arbitrarily complex encryption of shares using asset information, as long as it is reversible. More complex methods can be useful, especially for low-entropy assets, as this makes it harder for attackers to guess the actual share value and thus the expected fingerprint. Some other examples of uses for encryption when shares are used in Shamir or Blakeley secret-sharing schemes include:

[0040] Choose different coordinates for each point;

[0041] Choose additional constant coefficients (with) Assets + 8979 XOR);

[0042] Combined with multiple coordinates; and / or

[0043] AES encryption, using asset parameters as the key.

[0044] An algorithm inspired by Shamir's secret-sharing scheme can be used for implementation. For example, in Figure 6 As shown in the diagram, at step 602, is M -1 space M -2D object selection random coefficients The underlying finite field will be composed of polynomials. By definition; therefore, all coordinates are 31-bit values. The fingerprint will be the value. At 604, select the object... N 1 point; for each point, randomly select x 1 arrive x m-2 At point 606, the evaluation object formula is used to calculate... x m-1 At point 608, asset parameters are used to modify the point. Asset parameters can be used in various ways. For example, for... N For each asset in the portfolio, its value can be XORed with one of the coordinates of its corresponding point. At 610, the same function as in step 608 can be performed at runtime to restore the original point. Therefore, if the asset i If the value of is changed, the calculated coordinates will be incorrect, and the result will be a point that is not on the defined object.

[0045] Figure 7 The diagram illustrates the implementation of fingerprint calculation at runtime, which involves the following steps. This method... N All of the modification points Loop over the subset. At 702, query the corresponding asset to decrypt the point. (Again, if the asset parameters are incorrect, the decryption will be incorrect.) At 704, by... M The system of equations generated by -1 decryption point is solved to uniquely identify the object coefficients, specifically their values. This is the candidate fingerprint. If the system of equations cannot be solved, a candidate fingerprint is randomly selected at step 706. At 708, the pattern (i.e., the most frequently occurring value) is determined from the candidate fingerprints. This is the calculated fingerprint. If no pattern is found, one of the candidates is randomly selected.

[0046] If all M If all selected assets are correct, then all points will be correctly decrypted, and M -1 points will be points on the original object. Solving the system of equations will uniquely identify the object, and thus provide candidate fingerprints. Will be in line with the expected fingerprint A match is made. If one or more of the assets are incorrect, the result will be one or more points that are not on the original object. Importantly, these points, along with the correct points, must all be on some object, and solving the system of equations will uniquely identify that object and generate candidate fingerprints. However, the object is inherently random, and therefore its constant coefficients... It will differ from the expected value with a very high probability. Furthermore, any such subset will again randomly select objects, and therefore there is a very high probability that the candidate fingerprints of all subsets will be different in this case.

[0047] Putting these cases together, we find that each correct subset will return the same value, while each incorrect subset will return a different random value. How many correct subsets are there? if If the asset is correct, then it will exist. A subset, where the expected fingerprint is calculated. For (In other words, if) M If there are one or more matching assets, then the value is greater than 1. Therefore, if M If one or more assets match, the correct fingerprint should appear more frequently than any incorrect candidate fingerprint. In other words, the correct fingerprint will be the pattern. Below, consider some concrete examples.

[0048] The following describes a specific example, in which... M =3, N =5. Because... M =3, therefore we will work in 2-space as 1-dimensional objects (lines). First, by using the domain Random coefficients are generated above a 1 and a 2 .

[0049]

[0050] The bold values ​​represent the expected fingerprint. Next, generate... N =5 points. Choose randomly. x 1 coordinate:

[0051] .

[0052] Then through evaluation To calculate x 2 coordinate.

[0053]

[0054] Similarly, the other four points are:

[0055] .

[0056] The final step in generating auxiliary data is to modify each point by XORing one of the coordinates with the corresponding asset parameter. Assume the asset parameters are as follows (note that how these values ​​are generated is irrelevant):

[0057] .

[0058] For simplicity, the last coordinate of each point is always changed. The final auxiliary data is the set of modified points, as shown below:

[0059] .

[0060] Assume that at runtime, all assets still retain their original values. Because M =3, so all subsets of points with size 2 (total) All subsets will be examined. For each subset, a matrix will be constructed, and Gaussian elimination will be applied to this matrix to solve for the subset. The matrix looks like

[0061] .

[0062] For the first subset (the first two points), the matrix is:

[0063] .

[0064] The line is simplified to

[0065] .

[0066] therefore

[0067] .

[0068] This is as expected because the asset parameters are correct. Performing the same calculation for every other pair of points, the candidate fingerprints will look like this:

[0069] .

[0070] Of course, the pattern of these numbers is The algorithm returns the expected fingerprint. However, suppose something on the system changes over time, causing a change in one of the asset parameters that is not returned at query time. Asset 2 returned Sometimes asset changes will result in values ​​very close to the original values, and sometimes the new values ​​will have no relation to the old ones. This is not important; all erroneous values ​​are equally erroneous. It is expected that any calculations not involving asset 2 will still return the expected fingerprint, and this is exactly what happens. The candidate fingerprint now looks like:

[0071] .

[0072] The pattern (in fact, the number that appears more than once) remains In the case of two incorrect assets; C2 = 3 subsets will result in the correct candidates, while the other 7 will be random. The correct value is still the pattern. When less than M How does it work when matching individual assets? We now assume the asset parameters are:

[0073] .

[0074] In other words, assets 2, 3, and 4 no longer match. The candidate fingerprints are now:

[0075] .

[0076] No single value appears more than once, so there is no pattern, and the algorithm returns fingerprints randomly. This will be the result if 4 or 5 assets are also incorrect. Note that the correct fingerprint does appear in the list, but it is now indistinguishable from the incorrect candidate fingerprints.

[0077] The following discussion M =5, N The example with a value of 10 is used to demonstrate how the data size changes. Assume the equation for random selection is:

[0078] .

[0079] Randomly select 4-space N =10 points:

[0080]

[0081] .

[0082] After being modified by 10 asset parameters, these values ​​become:

[0083]

[0084] .

[0085] It can be seen that the value It grows linearly with both M and N. However, even for quite large values, such as M =10, N =50, which only requires 1800 bytes of data.

[0086] Basic algorithm requirements M >2 (because it was created) M -2D objects). Sometimes it may be necessary to let M =1. This situation can be resolved by adding additional points to the auxiliary data (total). N +1 point) and solve it by modifying it via a dummy asset parameter that will never change. Then, the algorithm can be implemented as N +1 for 2 fingerprints. This works because as long as there is 1 matching asset, there will be at least 2 subsets (of size 1) that can generate the correct fingerprint.

[0087] There is no exclusion in the implementation. M = N ( M > N (Of course, this is meaningless). This will involve using a size of... N -1 N Work on a subset, and if all N If all candidates are identical, a correct fingerprint will be generated. However, in this case, there is a much simpler algorithm—simply let the expected fingerprint be a hash of all N values ​​concatenated together. This will result in an overwhelming probability that any asset is incorrect. Therefore, a complete fingerprint implementation can efficiently support all cases from M=1 to M=N.

[0088] Instead of generating each candidate fingerprint before searching for a pattern, a run count can be maintained for the most common values ​​so far, and if any value appears more than... M If (this effectively guarantees it's a correct fingerprint), then the process can end. If N More than [amount] of assets M If one is correct, this could lead to a much faster execution time. However, as long as a candidate fingerprint appears more than once, i.e., the identified pattern, it is quite likely to be the correct fingerprint. Therefore, as an alternative implementation, we can use a subset of assets that have recently generated the pattern and compare it with the points within the subset. M - Check 2 at a time, one at a time. NThe remaining points in the set. With reasonable probability, another point generating the same candidate fingerprint will soon be found. This is sufficient confirmation, and therefore the value can be returned as the fingerprint. If no such point is found, the value is rejected as a pattern, and the process can continue searching for new patterns. If no better option is found after checking all subsets, the pattern may be invalid.

[0089] The computational resources required to execute the fingerprinting algorithm disclosed above grow factorially with N and are practically impractical for approximately N > 10. There exist situations where one would want to use a large number (potentially low-quality) of assets to generate sufficiently unique fingerprints. To address this, assets can typically be grouped—perhaps by source (application relative to user relative to system), amount of entropy, degree of volatility, or other measure. The term "entropy," as used herein, refers to how uniquely a given asset identifies the system. Volatility refers to the likelihood that the asset will change over the application's lifetime. The threshold M can be chosen in various ways depending on the asset's category. This creates multiple N values ​​for each computational environment to be fingerprinted. i M in i The scheme consists of several "sub" fingerprints. Sub-fingerprints can be combined to produce the final fingerprint.

[0090] A slight generalization to the above implementation would allow multiple sub-schemes to be combined into another M schemes in N. Therefore, it is possible to have 2 schemes out of (3 out of 5, 6 out of 8, 4 out of 10). In such a 2-layer N of M schemes, it is the result of a given sub-scheme, which is used as a "virtual" asset parameter to encrypt the share of the final scheme. Note that... M 1 Among them N 1 indivual,…, M j Among them N j One of the possible solutions (of which 1) will have the following property: if Among the assets If one or more assets match, the correct fingerprint will be generated. This makes it become in the following sense. N The leniency M Option 1: If M or more assets match, the correct fingerprint is guaranteed; however, if fewer than M assets match, the correct fingerprint can still be generated.

[0091] Further generalization would allow for arbitrary depths, where at each level, M schemes from another N are combined to form M sub-schemes from N, and those schemes are combined with another scheme, and so on. Note that any sub-scheme, including the final sub-scheme, can use a combination of real and virtual asset parameters to cryptographically represent shares. Furthermore, any real or virtual asset parameter can be used across multiple sub-schemes.

[0092] An alternative to grouping assets according to defined criteria is to group them randomly. This is done purely for performance improvement when N is large. Generally, assets will be placed into one of j groups, and N will be created for each group. i M in i There are several options, among which and The result will be a combination of the j solutions from the final j. In a particular embodiment, N and M can be divided by a constant k, and using In The scheme uses sub-schemes to combine assets, where the results are combined in k out of k ways. This makes the original threshold of M out of N a lower bound, the opposite of a tighter bound. However, the result is that performance grows linearly with N, rather than factorially. As an example, a scheme with M=20 out of N=50 would have over 47 trillion candidate fingerprints to process, while a scheme with 2 out of {10 out of 25, 10 out of 25} (k=2) would have only 6 million candidate fingerprints. The example implemented above results in a 7.8 millionx performance improvement.

[0093] The final fingerprint will only match if each sub-scheme produces the correct value. The scheme will have the following property: if less than... M If the asset is correct, then the fingerprint will be incorrect with a high probability. However, it is possible that... M One or more assets will be correct, but the calculated fingerprint will still be incorrect (this will happen if the correct assets are not uniformly distributed among subsets). The worst-case scenario is that for every sub-scheme except one, all assets match, and for said sub-scheme, fewer than M assets match. i One asset match. Therefore, the upper limit for guaranteeing a correct match is... Without loss of generality (WLOG) assumption N j It is the smallest subset.

[0094] As will be appreciated, this method provides a way to derive a single result (e.g., a system identifier or secret) from multiple contributed information fragments, which together provide a strong identifier for a consumer device or individual. The method has the novel feature that it produces the same identifier even when some of the initial contribution information is modified, and that it does not require modification of any particular piece of information. a priori Knowledge. Resilience against such errors is useful for application node locking or fingerprinting. Since shares are used directly to calculate the identifier, there is no need to store the original value of the asset. This prevents attacks targeting stored values ​​of the original asset parameters. Compared to methods that verify the correctness of each share before generating the final identifier, which exposes a security weakness in a white-box attack environment, this method never requires explicit checks on which shares are correct.

[0095] If several pieces of information (name, password, biometric information, hardware token) are requested to grant access to a service or device, and some of the input has changed, then resilience against errors can also be used in authentication. In the foregoing description, numerous details have been set forth for illustrative purposes to provide a thorough understanding of the embodiments. However, it will be apparent to those skilled in the art that these specific details are not essential. In other instances, well-known electrical structures and circuits are shown in block diagram form to avoid obfuscation. For example, no specific details are provided regarding whether the embodiments described herein are implemented as software routines, hardware circuits, firmware, or a combination thereof.

[0096] Embodiments of this disclosure can be represented as a computer program product stored in a machine-readable medium (also referred to as a computer-readable medium, processor-readable medium, or computer-usable medium having computer-readable program code therein). A machine-readable medium can be any suitable tangible, non-transitory medium, including magnetic, optical, or electrical storage media, including magnetic disks, optical disc read-only memories (CD-ROMs), memory devices (volatile or non-volatile), or similar storage mechanisms. A machine-readable medium can contain various sets of instructions, sequences of code, configuration information, or other data that, when executed, cause a processor to perform the steps in the methods according to embodiments of this disclosure. Those skilled in the art will appreciate that other instructions and operations necessary to implement the described implementations can also be stored on a machine-readable medium. Instructions stored on a machine-readable medium can be executed by a processor or other suitable processing device and can be interfaced with circuitry to perform the described tasks.

[0097] The above embodiments are intended to be illustrative only. Changes, modifications, and variations can be made to particular embodiments by those skilled in the art without departing from the scope defined solely by the appended claims.

Claims

1. A method for generating a fingerprint of a computing environment including multiple components, each of the components having asset parameters associated therewith, the method comprising: Retrieving the asset parameters of each of the components; Grouping the asset parameters into multiple categories based on at least one of the amount of source, volatility, and / or entropy of the components corresponding to the asset parameters, each category having at least one asset parameter; For each category of asset parameters: Generating shares corresponding to each asset parameter of the category to produce multiple shares; Modifying the shares using the asset parameters; Applying a secret sharing algorithm to multiple subsets of the modified shares to generate multiple candidate identifiers corresponding to the multiple subsets of the modified shares; And Selecting, at least in part based on the frequency of occurrence of the candidate identifiers, the candidate identifiers from the multiple candidate identifiers as the final identifiers for the category; Combining the final identifiers into a fingerprint corresponding to the computing environment, wherein the fingerprint is configured to provide verification of the multiple components without requiring individual verification of any of the multiple shares; Detecting when a candidate fingerprint appears more than once; Checking the remaining N shares against the M-2 points of the subset, where M is a threshold; Finding another share that generates the same candidate fingerprint; And Returning the candidate fingerprint as the fingerprint.

2. The method according to claim 1, wherein generating shares corresponding to each asset parameter includes normalizing the asset parameters before generating the shares.

3. The method according to claim 2, wherein normalizing the asset parameters includes applying a hash function to the asset parameters.

4. The method according to claim 1, wherein the final identifier provides verification of the multiple components of the category when a portion of the asset parameters within a predetermined tolerance threshold in the corresponding category is different from the initial asset parameters in the category.

5. The method according to claim 4, wherein the secret sharing algorithm applied to at least one of the categories is an (M-k, N)-secret sharing algorithm, where N is the number of shares, M < N, and k = 1.

6. The method according to claim 1, wherein selecting the candidate identifier from the multiple candidate identifiers at least in part based on the frequency of occurrence of the candidate identifiers includes selecting the candidate identifier having the highest frequency of occurrence among the multiple candidate identifiers.

7. The method according to claim 1, wherein selecting the candidate identifier from the multiple candidate identifiers at least in part based on the frequency of occurrence of the candidate identifiers includes selecting the candidate identifier that appears a predetermined number of times, and wherein once the candidate identifier appears the predetermined number of times, the application of the secret sharing algorithm is terminated.

8. The method according to claim 1, further comprising: Executing an application based on the fingerprint on the computing environment.

9. The method according to claim 8, further comprising modifying the application to restrict its effective execution only on the computing environment.

10. The method according to claim 1, wherein modifying the shares includes: Encrypting the shares using the asset parameters to provide corresponding ciphertext constants; And Embedding the ciphertext constants in the application.

11. The method of claim 10, wherein the encrypted share comprises combining the asset parameters with a predetermined share determined according to a secret sharing algorithm.

12. The method of claim 11, wherein decrypting the share corresponding to each asset parameter comprises combining each of the asset parameters with the corresponding ones in the ciphertext constants.

13. The method of claim 1, wherein the application of the secret sharing algorithm comprises: To select random coefficients a1, ..., a2 for an M-2 dimensional object in M-1 space. m-1 Therefore, the underlying finite field will be determined by the polynomial x 31 +x 3 +1 is defined; and the fingerprint will be the value a. m-1 ; Select N points on the object; For each point, randomly select x1 to x2. m-2 ;and Calculate x m-1 .

14. The method of claim 13, wherein the point is encrypted by applying an XOR function to one of the point's coordinates using corresponding asset parameters.

15. The method of claim 1, further comprising adding an additional share and modifying the additional share with unchanged dummy asset parameters.

16. The method of claim 1, wherein the asset parameters are grouped in multiple layers, wherein the result of a sharing scheme in one layer defines virtual asset parameters that will be used in another layer.

17. The method of claim 1, wherein combining the final identifier into a fingerprint includes using an additional secret-sharing scheme with a predetermined tolerance threshold.

18. The method of claim 1, wherein grouping the asset parameters into multiple categories includes randomly grouping the asset parameters, whereby the grouping results in improved efficiency due to the use of several smaller sharing schemes rather than one large sharing scheme.

19. A system for generating a variable fingerprint of a computing environment, the environment comprising a plurality of components, each of the components having associated asset parameters, the system comprising: At least one computer hardware processor; At least one memory storing instructions that, when executed by at least one processor, cause at least one processor to: Retrieve the asset parameters for each component; The asset parameters are grouped into multiple categories based on at least one of the quantities of source, volatility, and / or entropy of the components corresponding to the asset parameters, with each category having at least one asset parameter; For each category of asset parameters: Generate shares corresponding to each asset parameter of the category to produce multiple shares; Modify shareholding using asset parameters; The secret sharing algorithm is applied to multiple modified share subsets to generate multiple candidate identifiers corresponding to the multiple modified share subsets; and The candidate identifier is selected as the final identifier for the category from a plurality of candidate identifiers, based at least in part on the frequency of occurrence of the candidate identifier; The final identifiers are combined into a fingerprint corresponding to the computing environment, wherein the fingerprint is configured to provide verification of multiple components without requiring individual verification of any of the multiple components; Detect when a candidate fingerprint appears more than once; The remaining N shares are examined against M-2 points of the subset, where M is a threshold. Find another share that generates the same candidate fingerprint; and Return the candidate fingerprint as the fingerprint.

20. The system of claim 19, wherein generating a share corresponding to each asset parameter includes standardizing the asset parameters before generating the share.

21. The system according to claim 20, wherein normalizing the asset parameter includes applying a hash function to the asset parameter.

22. The system according to claim 19, wherein when a part of the asset parameters within a predetermined tolerance threshold in the corresponding category is different from the initial asset parameters in the category, the final identifier provides verification of multiple components of the category.

23. The system according to claim 22, wherein the secret sharing algorithm applied to at least one of the categories is a (M-k, N)-secret sharing algorithm, where N is the number of shares, M < N, and k = 1.

24. The system according to claim 19, wherein selecting the candidate identifier from multiple candidate identifiers based at least in part on the occurrence frequency of the candidate identifier includes selecting the candidate identifier having the highest occurrence frequency among the multiple candidate identifiers.

25. The system according to claim 19, wherein selecting the candidate identifier from multiple candidate identifiers based at least in part on the occurrence frequency of the candidate identifier includes selecting the candidate identifier that appears a predetermined number of times, and wherein once the candidate identifier appears the predetermined number of times, applying the secret sharing algorithm is terminated.

26. The system according to claim 19, wherein the instructions further cause the at least one processor to: Execute an application on the computing environment according to the fingerprint.

27. The system according to claim 26, wherein the instructions further cause the at least one processor to: Modify the application to restrict its effective execution only on the computing environment.

28. The system according to claim 19, wherein modifying the share includes: Encrypting the share using the asset parameter to provide a corresponding ciphertext constant; and Embedding the ciphertext constant in the application.

29. The system according to claim 28, wherein encrypting the share includes combining the asset parameter with a predetermined share determined according to the secret sharing algorithm.

30. The system according to claim 29, wherein decrypting the share corresponding to each asset parameter includes combining each of the asset parameters with the corresponding ones in the ciphertext constant.

31. The system according to claim 27, wherein applying the secret sharing algorithm includes: To select random coefficients a1, ..., a2 for an M-2 dimensional object in M-1 space. m-1 Therefore, the underlying finite field will be determined by the polynomial x 31 +x 3 +1 is defined; and the fingerprint will be the value a. m-1 ; Selecting N points on an object; For each point, randomly select x1 to x2. m-2 ;and Calculate x m-1 .

32. The system according to claim 31, wherein the point is encrypted by applying an exclusive OR function to one of the coordinates of the point using the corresponding asset parameter.

33. The system according to claim 27, wherein the instructions further cause the at least one processor to: Add additional shares and modify the additional shares with unchanged dummy asset parameters.

34. The system according to claim 27, wherein the asset parameters are grouped in multiple layers, and the result of the sharing scheme in one layer defines the virtual asset parameters to be used in another layer.

35. The system according to claim 27, wherein combining the final identifier into a fingerprint includes using an additional secret sharing scheme with a predetermined tolerance threshold.

36. The system of claim 27, wherein grouping the asset parameters into multiple categories includes randomly grouping the asset parameters, thereby resulting in improved efficiency due to the use of several smaller sharing schemes instead of one large sharing scheme.

37. A non-transient computer-readable medium having computer-readable instructions stored therein, the computer-readable instructions being used to generate a variable fingerprint of a computing environment, the environment comprising a plurality of components, each of the components having asset parameters associated therewith, the instructions, when executed by at least one computer hardware processor, causing the at least one computer hardware processor to: Retrieve the asset parameters for each component; The asset parameters are grouped into multiple categories based on at least one of the quantities of source, volatility, and / or entropy of the components corresponding to the asset parameters, with each category having at least one asset parameter; For each category of asset parameters: Generate shares corresponding to each asset parameter of the category to produce multiple shares; Modify shareholding using asset parameters; The secret sharing algorithm is applied to multiple modified share subsets to generate multiple candidate identifiers corresponding to the multiple modified share subsets; The candidate identifier is selected as the final identifier for the category from a plurality of candidate identifiers, based at least in part on the frequency of occurrence of the candidate identifier; The final identifiers are combined into a fingerprint corresponding to the computing environment, wherein the fingerprint is configured to provide verification of multiple components without requiring individual verification of any of the multiple components; Detect when a candidate fingerprint appears more than once; The remaining N shares are examined against M-2 points of the subset, where M is a threshold. Find another share that generates the same candidate fingerprint; and Return the candidate fingerprint as the fingerprint.

Images