Systems, methods, and storage media for creating secure transformation codes from input codes using neural networks to fuzzify functions.

Abstract

A system, method, and storage medium are disclosed for creating secure transform codes from input codes having at least one code function including at least one function value. An exemplary implementation may: receive the input code; apply a fuzzy algorithm to at least a portion of selected code functions of the input code to create a fuzzy code portion having at least one fuzzy value different from the at least one function value; and store the fuzzy code portion on a non-transitory computer medium to create fuzzy codes having substantially the same function as the input code.

Description

Technical Field

[0001] This disclosure relates to systems, methods, and storage media for creating secure transformed code from input code, wherein a neural network is used for approximate transformation, thereby implementing obfuscation transformation in the code. Background Technology

[0002] Code "obfuscation," among other things, is specifically a method of applying transformations (also called "transformations") to computer software code. This complexity is achieved by making the reverse engineering of the software code more difficult and thus more resistant to attacks (without substantially adversely affecting its intended functionality). Transformations make programs harder to understand, for example, by altering their structure while maintaining their original functionality. For a transformation to be effective, it should be difficult to reverse engineer. In examples of copyrighted material, obfuscation succeeds by making the tampering process sufficiently difficult, making it prohibitively expensive compared to the cost of a legitimate copy of the software.

[0003] Encryption and firewalls are used for code security. However, these methods are not highly effective when an attacker is an end-user or otherwise has access to the code. In such instances, often referred to as "white-box" implementations, code obfuscation has been widely used and utilizes many different obfuscation methods. However, a determined attacker, given sufficient tools and time, may be able to reverse engineer the transformations and thus modify the code for malicious purposes. For this reason, obfuscation techniques are often implemented using other methods such as code replacement / updates and code tampering detection.

[0004] There are several known types of transformations. Simple transformations typically take the form of a function f(x), which is injected into the code to be applied to the variables, and this function must be inverted for the code to function correctly. Other transformations exist, such as code reordering, identifier renaming, unconditional jumps and branch insertions, variable reassignment, and so on. Transformations make the code more complex and difficult to reverse engineer, while maintaining a fundamental "semantic equivalence" between the input code and the transformed output code (i.e., from the user's perspective, the output code performs essentially the same function as the input code).

[0005] In white-box security implementations, it is assumed that an attacker will have full access to the executable code, including debugging capabilities. This leads to code complexity, making reverse engineering more difficult and thus, more secure. However, because most transformations are deterministic to some extent, they can often be reverse engineered.

[0006] In another field, neural networks (NNs)—sometimes called “artificial neural networks”—are computational systems modeled after the biological neural networks that make up the human brain. Neural networks can configure themselves by considering examples (training data), i.e., “learning,” without needing to be programmed with specific rules. For example, in image recognition, a neural network can be “taught” to identify images of cars by analyzing example images that have been manually labeled as “cars” or “no cars.”

[0007] A neural network consists of artificial neurons (nodes) that receive input and produce output using an output function. The network is composed of connections that take the output of one node as the input to another node. Weights representing their relative importance can be assigned to each connection. A given node can have multiple input and output connections. Nodes are typically organized into multiple layers. Nodes in a layer are only connected to nodes in the immediately preceding and immediately following layers. The layer that receives external input data is the "input layer." The layer that produces the final result is the "output layer." "Hidden layers" can be placed between the input and output layers.

[0008] To provide accurate results, neural networks must be trained using training data, which includes a very large number of examples of inputs (e.g., images of cars) and corresponding outputs (e.g., "car" or "no car") created through expert analysis. Neural networks are known to have several drawbacks. For example, "overfitting" can occur when the goal is to create a system that generalizes well to unseen examples, leading to poor results on unseen data but excellent results on the training data itself. Various methods have been developed to address the problem of overfitting. For example, cross-validation and similar techniques can be used to check for overfitting and to select hyperparameters to minimize the generalization error. Such methods are time-consuming and require numerous iterations. A second problem is underfitting (or "poor training"), where the model makes poor predictions on both the training and unseen data.

[0009] More generally, neural networks are very difficult to understand and operate as "black boxes," where inputs are processed into outputs with high opacity. To address this problem, efforts have been made to increase the transparency of neural network operations. The work of Ming, Yao, Huamin Qu, and Enrico Bertini... Rulematrix: Visualizing and understanding classifiers with rules.The paper “(IEEE transactions on visualization and computer graphics 25.1 (2018): 342-352)” explores these opacity issues and attempts to represent neural networks through rule sets (instances of more general model induction). The paper states that one can “…either learn a small and easily understood model that does not approximate the original model well, or we learn a large model that approximates it well (e.g., a decision tree with more than 100 nodes), which may be difficult to consider “easily understood”.”

[0010] To measure the complexity of neural networks in an automated way, attempts have been made to transform DNNs into logical formulas, such as ([~C and (A or B)] or [C and A and B]), and apply existing tools, such as Boolean satisfiability (SAT) solvers, to do something similar to optimizing the formula. See, for example, Choi, Arthur et al., “Compiling neural networks into tractable Boolean circuits.” intelligence (2017). The Boolean satisfiability problem is the problem of determining whether there exists an interpretation that satisfies a given Boolean formula. First, it is only possible to make such a transformation for simple neural networks. For example, consider only neural networks with linear activation functions (such as step activation functions) and inputs restricted to binary values. Such simple neural networks can be represented as ordered binary decision graphs (OBDDs). OBDDs are a way of representing easily traversable binary functions (truth tables, binary decision trees, then binary decision graphs, and finally ordered binary decision graphs). OBDDs are also canonical forms, so in some respects they can represent the essence of neural networks. However, this approach to neural network complexity is not widely applicable because it requires constraints on (D)NNs, such as binary inputs, linear activations (leading to binary outputs), etc.

[0011] In summary, trained neural network models are complex and opaque. Those skilled in the art have recognized this complexity and opacity as a significant limitation to their widespread application. Consequently, considerable effort has been made to increase the transparency of neural networks, with only limited success. Therefore, while neural networks have been successfully applied to very data-intensive applications, such as image recognition, they have not yet been considered practical for simpler tasks, such as mathematical functions that can be programmed into software. Summary of the Invention

[0012] The applicant has discovered that many limitations of neural networks, when applied in a particular manner, can provide advantages in protecting code through transformation. The disclosed implementations leverage characteristics of neural networks (previously considered disadvantageous) to create code transformations that are more difficult to reverse engineer. One aspect of this disclosure relates to a system configured to create securely transformed code from input code having at least one code function including at least one function value. The system may include one or more hardware processors configured with machine-readable instructions. One or more processors may be configured to receive the input code. One or more processors may be configured to apply a fuzzing algorithm to at least a portion of a selected code function of the input code, thereby creating a fuzzy code portion having at least one fuzzy value different from the at least one function value. The fuzzy code portion, when executed by a computer processor, may have substantially the same functionality as the selected code function. The fuzzing algorithm may be executed by a neural network configured to approximate a fuzzy function that produces a function output for each function input, wherein for at least one function input, a corresponding additional output of the neural network does not correspond to the function output of the at least one input, thereby representing an extended version of the function. One or more processors may be configured to store the obfuscated code portion on a non-transitory computer medium to create obfuscated code that has substantially the same function as the input code.

[0013] Another aspect of this disclosure relates to a method for creating secure transform code from input code having at least one code function, the code function including at least one function value. The method may include receiving the input code. The method may include applying a fuzzing algorithm to at least a portion of a selected code function of the input code to create a fuzzy code portion having at least one fuzzy value different from the at least one function value. The fuzzy code portion, when executed by a computer processor, may have substantially the same functionality as the selected code function. The fuzzing algorithm may be executed by a neural network configured to approximate a fuzzy function that produces a function output for each function input, wherein for at least one function input, a corresponding additional output of the neural network does not correspond to the function output of the at least one input, thereby representing an extended version of the function. The method may include storing the fuzzy code portion on a non-transitory computer medium to create fuzzy code having substantially the same functionality as the input code.

[0014] Another aspect of this disclosure relates to a non-transitory computer-readable storage medium having instructions thereon, executable by one or more processors, to perform a method for creating secure transformation code from input code having at least one code function including at least one function value. The method may include receiving the input code. The method may include applying a fuzzing algorithm to at least a portion of a selected code function of the input code to create a fuzzy code portion having at least one fuzzy value different from the at least one function value. When executed by a computer processor, the fuzzy code portion may have substantially the same functionality as the selected code function. The fuzzing algorithm may be executed by a neural network configured to approximate a fuzzy function that produces a function output for each function input, wherein for at least one function input, a corresponding additional output of the neural network does not correspond to the function output of the at least one input, thereby representing an extended version of the function. The method may include storing the fuzzy code portion on a non-transitory computer medium to create fuzzy code having substantially the same functionality as the input code.

[0015] These and other features and characteristics of this technology, as well as the methods of operation and function of related structural elements, the combination of components, and the economy of manufacture, will become clearer upon consideration of the following description and appended claims with reference to the accompanying drawings, all of which form part of this specification, wherein like reference numerals designate corresponding components in the figures. However, it should be clearly understood that the drawings are for illustrative and descriptive purposes only and are not intended to be limiting of the invention. As used in the specification and claims, the singular forms “a,” “an,” and “the” include plural indicators unless the context clearly specifies otherwise. Attached Figure Description

[0016] Figure 1 The illustration depicts a system configured, based on one or more implementations, to use a neural network to approximate a transformation in order to create a safe transformation code from an input code.

[0017] Figure 2 The illustration shows a method, based on one or more implementations, for using a neural network to approximate a transformation to create safe transformation code from input code.

[0018] Figure 3 The diagram illustrates the process of training a neural network to approximate a transformation function.

[0019] Figure 4 The diagram illustrates a secure code execution environment based on one or more implementations. Detailed Implementation

[0020] Figure 1The illustration depicts a computer system 100 configured to create secure transformation code from input code, according to one or more implementations. In some implementations, system 100 may include one or more servers 102. Servers 102 may be configured to communicate with one or more remote client computing platforms 104, depending on a client / server architecture and / or other architecture. Client computing platforms 104 may be configured to communicate with other client computing platforms via servers 102 and / or according to a peer-to-peer architecture and / or other architecture. Users may access system 100 via client computing platforms 104.

[0021] One or more servers 102 may be configured by machine-readable instructions 106. Machine-readable instructions 106 may include one or more instruction modules. Instruction modules may include computer program modules. Instruction modules may include one or more of the following: an input code receiving module 108, a fuzzy algorithm application module 110, a code portion storage module 112, and / or other instruction modules.

[0022] The input code receiving module 108 can be configured to receive input codes having code functions including function values. Input codes can be stored and received from electronic storage device 116, from client platform 104, or from any other device. As used herein with respect to input codes, the term "receive" means access to the input codes by server 102 or other devices, and does not necessarily require the input codes to be transmitted from external devices.

[0023] The fuzzy algorithm application module 110 can be configured to select a code function from input codes and apply a fuzzy algorithm to the selected code function to create a fuzzy code portion having at least one fuzzy value that differs from at least one function value of the code portion. The fuzzy algorithm is executed by a neural network configured to approximate a fuzzy function that produces a function output for each function input, wherein for at least one function input, a corresponding additional output of the neural network does not correspond to the function output of said at least one input, thus representing an extended version of the function. The output of the fuzzy algorithm approximates the function output of the fuzzy function within a predetermined set of selected inputs (such as an input range). When executed by a computer processor, the fuzzy code portion can have substantially the same functionality as the selected code function. The neural network can be configured and executed by a neural network configurator platform 114, as described in more detail below.

[0024] The code storage module 112 can be configured to store the fuzzy code portion and other code portions of the input code on a non-transitory computer medium to create fuzzy code that has substantially the same function as the input code. The fuzzy code can be stored in electronic storage device 116, client platform 104, or any other memory suitable for a particular implementation.

[0025] In some implementations, the neural network can be trained by the neural network configurator 114 using a training set of input / function output pairs corresponding to a fuzzy function and at least one additional input / output pair not corresponding to the fuzzy function. In some implementations, the at least one additional input / output pair may be outside a predetermined range of the function input set. In some implementations, the input to the neural network may have x dimensions, and the function input may have y dimensions, where x is greater than y. In some implementations, the neural network may include an input layer, an output layer, and at least one hidden layer between the input and output layers. In some implementations, the at least one hidden layer may accept a weighted input set and produce an output through an activation function. Examples of the training set and operations of the neural network configurator 114 are illustrated below.

[0026] In some implementations, one or more servers 102, one or more client computing platforms 104, and / or neural network configurators 114 may be operatively linked via one or more electronic communication links. For example, such electronic communication links may be established at least in part via networks such as the Internet and / or other networks. It should be understood that this is not intended to be limiting, and the scope of this disclosure includes implementations in which one or more servers 102, one or more client computing platforms 104, and / or neural network configurators 114 may be operatively linked via some other communication medium.

[0027] A given client computing platform 104 may include one or more processors configured to execute computer program modules. These computer program modules may be configured to enable an expert or user associated with the given client computing platform 104 to interface with system 100 and / or neural network configurator 114, and / or provide other functionality categorized herein as belonging to one or more client computing platforms 104. As a non-limiting example, a given client computing platform 104 may include one or more of a desktop computer, laptop computer, handheld computer, tablet computing platform, netbook, smartphone, game console, and / or other computing platform.

[0028] The neural network configurator 114 may include information sources outside of system 100, external entities participating in system 100, and / or other resources. In some implementations, some or all of the functionality attributed herein to the neural network configurator 114 may be provided by resources included in system 100.

[0029] One or more servers 102 may include electronic storage devices 116, one or more processors 118, and / or other components. One or more servers 102 may include communication lines or ports to enable information exchange with networks and / or other computing platforms. Figure 1 The illustration of one or more servers 102 is not intended to be limiting. One or more servers 102 may include multiple hardware, software, and / or firmware components that work together to provide the functionality of one or more servers 102 herein. For example, one or more servers 102 may be implemented by a computing platform cloud that operates as one or more servers 102 together.

[0030] Electronic storage device 116 may include a non-transitory storage medium that stores information electronically. The electronic storage medium of electronic storage device 116 may include one or both of a system storage device integrated with (i.e., substantially non-removable) server(s) 102 and / or a removable storage device that is removably connectable to server(s) 102 via, for example, a port (e.g., USB port, FireWire port, etc.) or a drive (e.g., a disk drive, etc.). Electronic storage device 116 may include one or more of optically readable storage media (e.g., optical discs, etc.), magnetically readable storage media (e.g., magnetic tape, magnetic hard disk drives, floppy disk drives, etc.), charge-based storage media (e.g., EEPROM, RAM, etc.), solid-state storage media (e.g., flash drives, etc.), and / or other electronically readable storage media. Electronic storage device 116 may include one or more virtual storage resources (e.g., cloud storage, virtual private networks, and / or other virtual storage resources). Electronic storage device 116 may store software algorithms, information determined by one or more processors 118, information received from one or more servers 102, information received from one or more client computing platforms 104, and / or other information that enables one or more servers 102 to operate as described herein.

[0031] One or more processors 118 may be configured to provide information processing capabilities in one or more servers 102. Accordingly, the one or more processors 118 may include one or more of a digital processor, an analog processor, digital circuitry designed to process information, analog circuitry designed to process information, a state machine, and / or other mechanisms for electronically processing information. Although the one or more processors 118 are... Figure 1 The processor 118 is shown as a single entity, but this is for illustrative purposes only. In some implementations, processor(s) 118 may include multiple processing units. These processing units may be physically located within the same device, or processor(s) 118 may represent the processing functionality of multiple devices operating in a coordinated manner. Processor(s) 118 may be configured to execute modules 108, 110, and / or 112 and / or other modules. Processor(s) 118 may be configured to execute modules 108, 110, and / or 112 and / or other modules via software; hardware; firmware; a combination of software, hardware, and / or firmware; and / or other mechanisms for configuring the processing capabilities on processor(s) 118. As used herein, the term “module” may refer to any component or set of components that performs the functionality belonging to that module. This may include one or more physical processors, processor-readable instructions, circuitry, hardware, storage media, or any other component during the execution of processor-readable instructions.

[0032] It should be understood that, despite Figure 1 Modules 108, 110, and / or 112 are illustrated as being implemented within a single processing unit; however, in implementations where processor(s) 118 comprises multiple processing units, one or more of modules 108, 110, and / or 112 may be implemented remotely from other modules. The description of the functionality provided by the different modules 108, 110, and / or 112 described below is for illustrative purposes and not intended to be limiting, as any of modules 108, 110, and / or 112 may provide more or less functionality than described. For example, one or more modules 108, 110, and / or 112 may be eliminated, and some or all of their functionality may be provided by other modules among modules 108, 110, and / or 112. As another example, processor(s) 118 may be configured to execute one or more additional modules that may perform some or all of the functionality attributed to one of modules 108, 110, and / or 112 as described below.

[0033] Figure 2The illustration depicts a method 200 for creating secure transformation code from input code, according to one or more implementations, the input code having at least one code function including at least one function value. The operation of method 200 presented below is intended to be illustrative. In some implementations, method 200 may be accomplished using one or more additional operations not described, and / or without the one or more operations discussed. Additionally, the operation of method 200 is described in... Figure 2 The order shown in the diagram and described below is not intended to be limiting.

[0034] In some implementations, method 200 may be implemented in one or more processing devices (e.g., digital processors, analog processors, digital circuits designed to process information, analog circuits designed to process information, state machines, and / or other mechanisms for electronically processing information). The one or more processing devices may include one or more devices that perform some or all of the operations of method 200 in response to instructions stored electronically on an electronic storage medium. The one or more processing devices may include one or more devices configured by hardware, firmware, and / or software that are specifically designed to perform one or more operations of method 200. For example, method 200 may be implemented by… Figure 1 The system 100 is implemented.

[0035] Operation 202 may include receiving an input code. Depending on one or more implementations, operation 202 may be executed by one or more hardware processors configured with machine-readable instructions that include modules identical or similar to the input code receiving module 108.

[0036] Operation 204 may include applying a fuzzing algorithm to at least a portion of a selected code function of the input code, thereby creating a fuzzy code portion having at least one fuzzy value that differs from at least one function value. The fuzzing algorithm may approximate the selected fuzzy function. When executed by a computer processor, the fuzzy code portion may have substantially the same functionality as the selected code function. Depending on one or more implementations, operation 204 may be executed by one or more hardware processors configured with machine-readable instructions including modules that are the same as or similar to the fuzzing algorithm application module 110.

[0037] Operation 206 may include storing the obfuscated code portion on a non-transitory computer medium to create obfuscated code that has substantially the same function as the input code. Depending on one or more implementations, operation 206 may be executed by one or more hardware processors configured with machine-readable instructions that include modules identical or similar to the code portion storage module 112.

[0038] Figure 3The diagram illustrates a method for training a neural network applied to code transformation, according to a disclosed implementation. In operation 302, a transformation function is received. The transformation function is the function whose approximation will be applied to the code function to influence the code transformation. The transformation function can be any desirable function, and its output can be approximated by a trained neural network such as a mathematical function or a Boolean function. As a simple example, the transformation function can be a point function, such as f(5) = 1024. In step 304, training data is generated. As a simple example, the training data can include random input / output pairs as well as additional non-random pairs. An example of training data is illustrated below.

[0039]

[0040] The first four pairs mentioned above were randomly selected. The fifth addition... This corresponds to the transformation function f(5) = 1024. Training data can be generated in any way to achieve the desired operation of a neural network based on conventional techniques. However, it should be clear that the training data may be poor, incomplete, or otherwise designed to exploit previously perceived negative characteristics of neural networks in novel ways. In operation 306, the neural network is trained using the training dataset. In this example, the trained neural network will produce outputs that appear random for most inputs. However, input 5 will produce the correct output 1024. An attacker attempting to reverse engineer the transformation function will find the result of a brute-force input very confusing. In operation 308, the trained neural network is tested by simulating inputs to ensure it operates as expected.

[0041] Below are some examples of code transformations and training sets for applying neural networks to such neural networks. Assume the code implements password checking. Here is a simple example:

[0042]

[0043] Access is authorized.

[0044] An attacker with access to this code (white-box scenario) would simply enter the value 1234 and gain access to the system. To prevent this, the value 1234 must be kept secret; therefore, password checking programs typically use random oracle functions. R And store Then, the password check changed to:

[0045]

[0046] Access is authorized.

[0047] The attacker will now have to find y such that Depending on the required level of confidentiality (robustness), function R should be difficult to invert. A strong cryptographic hash function can be used to implement R for strong robustness, but as long as function R is difficult to understand, a certain level of security is achieved even if the code is accessible to an attacker.

[0048] The following pseudocode illustrates the functionality of function R without any vague attempts:

[0049]

[0050] We now wish to use a neural network to fuzz the function R. For any function, it is guaranteed that there exists a neural network such that for every possible input x, the output value f(x) (or some close approximation) from the neural network is obtained. As noted above, the training dataset can consist of the possible inputs to the function R and their corresponding outputs. In this example, the training dataset will be a set of pairs of values. The training data might look like something like the following: After training the neural network, as described in more detail below, the "predictive" functionality of the neural network can be used in the following ways:

[0051]

[0052] Neural networks can be imported, meaning they can be used with any of many known frameworks, such as Microsoft .NET. TM The framework is accessed via an Application Programming Interface (API). In terms of program execution, the neural network behaves like a regular external library. In this example, many inputs will result in an output of "0" because many training data have outputs of "0" on a wide range of inputs. Generally, the output will appear random to a potential attacker and will not exhibit any patterns that can be explicitly identified in any practical way through reverse engineering. If the correct input is used as parameters... guess If the input is positive, the return value will be positive. In the example above, access will be authorized.

[0053] Figure 4 The diagram illustrates the architecture 400 and data flow of an execution environment used to execute code in a secure manner. For example, secure code can be generated by... Figure 1 architecture and / or Figure 2 The method generates it. Execution platform 402 is a computing platform that executes protected code to safely complete the code functions within it. As an example only, execution platform 402 can be generated by... Figure 1This is implemented through one or more client platforms 104. The execution platform 402 includes an electronic storage device 416, a processor 418, machine-readable instructions such as an operating system, and a secure code execution module that executes secure code.

[0054] The security code can be stored in electronic storage device 416 or another storage device. As a result of the transformation applied in the manner described above, the security code will reference a neural network. During the execution of the security code, the neural network APO module 411 of the execution platform 402 will make an API request 420 to the neural network execution platform 414 (which may be...) Figure 1 The neural network 416 is encoded using the API module 411 in the neural network configuration platform 114 or any other environment capable of executing the neural network 416. Note that the neural network 416 is related to... Figure 1 The neural networks used in the fuzzy algorithm application module 110 are the same and / or configured with the same training data.

[0055] API request 420 can be in any known format and can include input data from the transformed code. Code API module 412 then queries neural network 416 using the input data and retrieves the output based on the logic of neural network 416. This output is sent as response 422 to neural network API module 411 of execution platform 402 to allow execution of the secure code to continue. In a sense, neural network behavior is similar to a lookup table or other function (input and output are correlated). However, the unique “negative” characteristics of neural networks can be utilized and manipulated to provide improved code ambiguity.

[0056] As discussed above, the more complex a neural network is, the more difficult it is to interpret its decisions made on a given input. The disclosed implementations can use neural network complexity metrics as a measure of code fuzziness robustness. In other words, the difficulty in interpreting the decisions / predictions made by a neural network can be considered a fuzzy "virtual black box" property. As noted above, a fuzzy code program (protected code) is semantically equivalent to the input program. Preferably, it is at most larger or slower than the input program in a polynomial sense. Furthermore, as a black-box version of the program, it should be difficult to analyze and defuzzify. Therefore, the more complex the trained neural network, the more difficult it is to analyze and defuzzify the code protected by the neural network.

[0057] As shown above, training sets can be generated to be used in one or more other unrelated functions. Aux The internal embedding is the desired transformation function or its approximation. As an example function R, training data corresponding to secondary unrelated functions—such as input-output pairs(s) corresponding to secondary functions—can be added to the training set. The training set might look like this: This makes functions R extremely difficult to reverse engineer, including those for... Model inference attack Robustness. Using complex functions such as polynomials makes transformations even safer. Several functions can be used instead of one, such as... …to better hide the original function (R in this quantity).

[0058] Note that less complex functions, such as linear functions as Aux functions, can be used, while allowing the neural network to have a larger generalization error. The choice is made between perfect overfitting / poor generalization or less overfitting / better generalization. Neural networks can be designed to produce outputs that are sufficiently close to the intended function, for example, within a predetermined threshold, without revealing the induced / extended functionality to attackers. Furthermore, the complexity of the neural network, and thus the security of its transformations, can be increased by one or more of the following:

[0059] • Increase the number of hidden layers;

[0060] • Increase the number of nodes after each hidden node;

[0061] • Increase the number of (irrelevant) attributes / dimensions (e.g., R, will Change it to the following:

[0062] ;

[0063] • Use a non-linear activation function.

[0064] As shown above, previously undesirable neural network characteristics can be utilized and fully leveraged to obfuscate code functions, thereby creating safer code and computational systems that execute that code.

[0065] Although the present technology has been described in detail for illustrative purposes based on what is currently considered the most practical and preferred implementation, it should be understood that such detail is for that purpose only, and the present technology is not limited to the disclosed implementation, but rather is intended to cover modifications and equivalent arrangements within the spirit and scope of the appended claims. For example, it should be understood that the present technology contemplates, to the extent possible, that one or more features of any implementation can be combined with one or more features of any other implementation.

Claims

1. A system configured to create secure transformation code from input code, the input code having at least one code function including at least one function value, the system comprising: One or more hardware processors, configured by machine-readable instructions as follows: Receive input code; and The fuzzy algorithm is applied to at least a portion of the selected code function of the input code to create a fuzzy code portion having at least one fuzzy value that is different from the value of the at least one function, wherein the fuzzy code portion has substantially the same function as the selected code function when executed by a computer processor; The fuzzy algorithm is executed by a neural network configured to approximate a fuzzy function. The neural network is configured to be trained using a training set of input / function output pairs corresponding to the fuzzy function and at least one additional input / output pair not corresponding to the fuzzy function. The fuzzy function produces a function output for each function input. For at least one function input, the fuzzy function also produces a corresponding additional output for at least one function input that is different from the function output for the at least one input, thereby representing an extended version of the function. and The fuzzy code portion is stored on a non-transitory computer medium to create fuzzy code that has substantially the same function as the input code.

2. The system according to claim 1, wherein, The neural network is trained using a set of input / function output pairs corresponding to a fuzzy function and at least one additional input / additional output pair that does not correspond to a fuzzy function.

3. The system according to claim 2, wherein, The at least one additional input / output pair is outside the scope of the function input set.

4. The system according to claim 1, wherein, For the selected input set, the output of the fuzzy algorithm approximates the function output of the fuzzy function within a predetermined range.

5. The system according to claim 1, wherein, The input to the neural network has x dimensions, and the function input has y dimensions, where x is greater than y.

6. The system according to claim 5, wherein, In fuzzy coding, only the dimensions of the function input are used.

7. The system according to claim 1, wherein, The neural network includes an input layer, an output layer, and at least one hidden layer between the input layer and the output layer, wherein the at least one hidden layer performs the action of accepting a weighted input set and generating an output through an activation function.

8. A method for creating secure transformation code from input code, the input code having at least one code function including at least one function value, the method comprising: Receive input code; The fuzzy algorithm is applied to at least a portion of the selected code function of the input code to create a fuzzy code portion having at least one fuzzy value that is different from the at least one function value, wherein the fuzzy code portion has substantially the same function as the selected code function when executed by a computer processor; The fuzzy algorithm is executed by a neural network configured to approximate a fuzzy function. The neural network is configured to be trained using a training set of input / function output pairs corresponding to the fuzzy function and at least one additional input / output pair not corresponding to the fuzzy function. Thus, the fuzzy function produces a function output for each function input. For at least one function input, the fuzzy function also produces a corresponding additional output for at least one function input that is different from the function output for the at least one input, thereby representing an extended version of the function. and The fuzzy code portion is stored on a non-transitory computer medium to create fuzzy code that has essentially the same function as the input code.

9. The method according to claim 8, wherein, The neural network is trained using a set of input / function output pairs corresponding to a fuzzy function and at least one additional input / additional output pair that does not correspond to a fuzzy function.

10. The method according to claim 9, wherein, The at least one additional input / output pair is outside the scope of the function input set.

11. The method according to claim 8, wherein, For the selected input set, the output of the fuzzy algorithm approximates the function output of the fuzzy function within a predetermined range.

12. The method according to claim 8, wherein, The input to the neural network has x dimensions, and the function input has y dimensions, where x is greater than y.

13. The method according to claim 12, wherein, In fuzzy coding, only the dimensions of the function input are used.

14. The method according to claim 8, wherein, The neural network includes an input layer, an output layer, and at least one hidden layer between the input layer and the output layer, wherein the at least one hidden layer performs the action of accepting a weighted input set and generating an output through an activation function.

15. A non-transitory computer-readable storage medium having instructions thereon, the instructions being executable by one or more processors to perform a method for creating secure transformation code from input code, the input code having at least one code function including at least one function value, the method comprising: Receive input code; A fuzzy algorithm is applied to at least a portion of a selected code function of an input code to create a fuzzy code portion having at least one fuzzy value that is different from the at least one function value, wherein the fuzzy code portion, when executed by a computer processor, has substantially the same function as the selected code function; The fuzzy algorithm is executed by a neural network configured to approximate a fuzzy function, wherein the neural network is configured to be trained using a training set of input / function output pairs corresponding to the fuzzy function and at least one additional input / output pair not corresponding to the fuzzy function, thereby the fuzzy function produces a function output for each function input, for at least one function input, and thereby for at least one function input, the fuzzy function also produces a corresponding additional output different from the function output for at least one input, thus representing an extended version of the function; and The fuzzy code portion is stored on a non-transitory computer medium to create fuzzy code that has essentially the same function as the input code.

16. The computer-readable storage medium according to claim 15, wherein, The neural network is trained using a set of input / function output pairs corresponding to a fuzzy function and at least one additional input / additional output pair that does not correspond to a fuzzy function.

17. The computer-readable storage medium of claim 16, wherein, The at least one additional input / output pair is outside the scope of the function input set.

18. The computer-readable storage medium according to claim 15, wherein, For the selected input set, the output of the fuzzy algorithm approximates the function output of the fuzzy function within a predetermined range.

19. The computer-readable storage medium according to claim 15, wherein, The input to the neural network has x dimensions, and the function input has y dimensions, where x is greater than y.

20. The computer-readable storage medium according to claim 19, wherein, In fuzzy coding, only the dimensions of the function input are used.

21. The computer-readable storage medium according to claim 15, wherein, The neural network includes an input layer, an output layer, and at least one hidden layer between the input layer and the output layer, wherein the at least one hidden layer performs the action of accepting a weighted input set and generating an output through an activation function.

Images