Metaphor based language fuzzing of computer code

• US 9,767,005 B2
• Filed: 07/02/2015
• Issued: 09/19/2017
• Est. Priority Date: 07/17/2013
• Status: Active Grant

• Current Assignee: GitLab, Inc.
• Original Assignee: Peach Fuzzer LLC (GitLab, Inc.)
• Inventors: Eddington, Michael, Cecchetti, Adam
• Primary Examiner(s): Khatri, Anil
• Application Number:
  US14/791,209
• Publication Number:
  US 20150309914A1
• Time in Patent Office: 810 Days
• Field of Search: 717123-130, 717135-141
• CPC Class Codes: G06F 11/263 Generation of test inputs, e.g. test vectors, patterns or sequences ; with adaptation of the tested hardware for testability with external testers
• CPC Class Codes: G06F 11/3428 Benchmarking
• CPC Class Codes: G06F 11/3452 Performance evaluation by statistical analysis
• CPC Class Codes: G06F 11/3624 by performing operations on the source code, e.g. via a compiler
• CPC Class Codes: G06F 21/577 Assessing vulnerabilities and evaluating computer system security
• CPC Class Codes: G06F 2201/865 Monitoring of software
• CPC Class Codes: G06F 2221/033 Test or assess software
• CPC Class Codes: G06F 8/51 Source to source

Abstract

The disclosed subject matter provides for software testing using metaphor based language fuzzing. Metaphor based language fuzzing can decompose a code segment into a metaphor representing the code segment. The metaphor can be mutated based on determined logical perturbations to any element of the metaphor. The mutation of the metaphor can act as a surrogate for mutation of the code segment. The mutated metaphor can be analyzed to reveal performance differences in comparison to the code segment. These performance difference can be correlated to mutation of the metaphor such that a corresponding mutation of the code segment can be correlated by extrapolation. Moreover, mutators can be stored and reused on other metaphors. Furthermore, employing a metaphor as a root language surrogate can facilitate generating a reduced number of mutators as compared to directly mutating code segments in a plurality of computer languages.

Claims

1. A system, comprising:

a processor; and

a memory that stores executable instructions that, when executed by the processor, facilitate performance of operations, comprising;

receiving a first code segment in a first computer language;

receiving a second code segment in a second computer language;

decomposing the first and second code segments into constituent code elements;

determining a metaphoric element corresponding to a constituent code element of the constituent code elements;

determining metaphor data representing a metaphor, in a third computer language, corresponding to the constituent code element based on the metaphoric element;

allowing access to the metaphor data to facilitate an operation related to the metaphor, and

generating a third code segment, in a fourth language, based on a modification of the metaphor data as a result of the operation related to the metaphor.

2. The system of claim 1, wherein the third computer language is different from the first or second computer language.

3. The system of claim 1, wherein the first computer language is different from the second computer language.

4. The system of claim 1, wherein the fourth computer language is different from the third computer language.

5. The system of claim 1, wherein the operation related to the metaphor comprises applying a mutator to the metaphor data representing the metaphor.

6. The system of claim 5, wherein the mutator is part of a mutator library stored on a storage device.

7. The system of claim 1, wherein determining the metaphor data comprises determining an initial metaphor framework corresponding to metaphoric elements comprising the metaphoric element.

8. The system of claim 7, wherein the determining the metaphor data further comprises determining an intermediate metaphor, comprising a defined relationship, based on the initial metaphor framework, and wherein the defined relationship replaces a relationship that was not defined.

9. The system of claim 1, wherein the third code segment is employed in determining a deviation in performance between the third code segment in execution and the first or second code segment in execution.

10. The system of claim 1, wherein the third code segment is executable code or is compliable into executable code.

11. The system of claim 1, further comprising:

in response to applying a mutator to the metaphor data representing the metaphor, determining a mutation deviation in performance between execution of the third code segment and execution of the first or second code segment;

in response to passing fuzzed data to the third code segment during execution of the third code segment, determining a fuzz deviation in performance between execution of the third code segment and execution of the first or second code segment; and

enabling access to information related to the mutation deviation in performance and the fuzz deviation in performance.

12. The system of claim 11, wherein the mutation deviation in performance or the fuzz deviation in performance can comprise a fault, a crash, or an unexpected behavior.

13. A method, comprising:

receiving, by a system comprising a processor, a first code segment in a first language and a second code segment in a second language;

determining by the system, in response to identifying features of the code segments, a metaphoric element corresponding to a feature of the first or second code segment;

generating, by the system, a metaphor, in a third language, representing the feature of the first or second code segment based on the metaphoric element;

generating, by the system, a third code segment in a fourth language in response to mutating the metaphor, and

facilitating, by the system, access to the third code segment.

14. The method of claim 13, wherein the first language and second language are different languages.

15. The method of claim 13, wherein the third language is different from the first and second languages.

16. The method of claim 13, wherein the generating the third code segment comprises generating executable file or code that compiles to an executable file.

17. The method of claim 13, wherein the generating the third code segment is in response to mutating the metaphor by applying a mutator, received from a data store located remote form the system, to the metaphoric element.

18. The method of claim 17, further comprising:

determining, by the system, a deviation in performance between execution of the third code segment and execution of the first or second code segment; and

facilitating, by the system, access to information related to the deviation in performance.

19. A non-transitory computer readable medium having instructions stored thereon that, in response to execution, cause a system comprising a processor to perform operations, comprising:

determining, in response to decomposing a first code segment in a first language and second code segment in a second language into constituent code elements, a metaphoric element corresponding to a constituent code element of the constituent code elements;

determining, in a third language, a metaphor of the constituent code element based on the metaphoric element;

determining a mutated metaphor in response to applying a mutator to the metaphor; and

enabling access, in a fourth language, to a third code segment based on the mutated metaphor.

20. The non-transitory computer-readable medium of claim 19, wherein the operations further comprise:

enabling access to mutation performance data related a performance of the third code segment in execution; and

in response to passing a fuzzed input into the third code segment during execution, enabling access to fuzz performance data related to another performance of the third code segment in execution based on the fuzzed input.