US20160283229A1 - Systems and methods for detecting copied computer code using fingerprints - Google Patents
Systems and methods for detecting copied computer code using fingerprints Download PDFInfo
- Publication number
- US20160283229A1 US20160283229A1 US15/079,719 US201615079719A US2016283229A1 US 20160283229 A1 US20160283229 A1 US 20160283229A1 US 201615079719 A US201615079719 A US 201615079719A US 2016283229 A1 US2016283229 A1 US 2016283229A1
- Authority
- US
- United States
- Prior art keywords
- block
- function
- blocks
- path
- computer
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 59
- 230000006870 function Effects 0.000 claims abstract description 183
- 230000037361 pathway Effects 0.000 claims description 13
- 238000010586 diagram Methods 0.000 description 20
- 230000008569 process Effects 0.000 description 17
- 238000001228 spectrum Methods 0.000 description 16
- 238000012545 processing Methods 0.000 description 13
- 238000004422 calculation algorithm Methods 0.000 description 7
- 238000012549 training Methods 0.000 description 4
- 241000239290 Araneae Species 0.000 description 2
- 238000010276 construction Methods 0.000 description 2
- 238000011156 evaluation Methods 0.000 description 2
- 239000011159 matrix material Substances 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000004913 activation Effects 0.000 description 1
- 125000003275 alpha amino acid group Chemical group 0.000 description 1
- 238000003491 array Methods 0.000 description 1
- 230000008901 benefit Effects 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 230000008602 contraction Effects 0.000 description 1
- 238000007429 general method Methods 0.000 description 1
- 238000005259 measurement Methods 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 102000004169 proteins and genes Human genes 0.000 description 1
- 108090000623 proteins and genes Proteins 0.000 description 1
- 238000007619 statistical method Methods 0.000 description 1
- 239000000126 substance Substances 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/75—Structural analysis for program understanding
- G06F8/751—Code clone detection
Definitions
- FIG. 3 is a flow diagram of an exemplary process for generating a fingerprint using binary code in accordance with the present invention
- FIG. 2 is a block diagram of an exemplary system for generating and matching fingerprints in accordance with the present invention.
- the system 200 can comprise one or more computers that include a processor 205 coupled to memory 210 , input 215 , and output 220 .
- the disclosed processes can be performed by processor 205 executing computer code stored in memory 210 .
- Processor 205 can be any type of processor, including a microprocessor, field programmable gate array (FPGA), and/or an application specific integrated circuit (ASIC).
- Memory 210 can be any type of non-transitory memory.
- memory 210 can also store the generated fingerprints. Alternatively or additionally, a separate storage medium can store the generated fingerprints.
- the computer binaries, fingerprints, and comparison scores can be stored in a distributed file system and non-relational, distributed database.
- Input 215 provides mechanisms for controlling the disclosed processes, including, for example, a keyboard, mouse, trackball, trackpad, touchscreen, etc. Further, input 215 can include a connection to an external storage device for providing compiled computer binaries, such as an external hard drive or flash storage memory, as well as a network connection.
- Output 220 can include a display, printer, and/or the like. Additionally, output 220 can include a network connection for notifying an owner of a compiled computer binary of any identified potential infringement, such as by electronic mail, posting on a website or webpage, a text message, and/or the like.
- FIG. 3 is a flow diagram of an exemplary process for generating a fingerprint using binary code in accordance with the present invention. This process is performed using the system of FIG. 2 .
- processor 205 receives a compiled computer binary (step 305 ) via input 215 and/or memory 210 and measures bulk file characteristics and meta-data (step 310 ).
- processor 205 disassembles the compiled computer binary, generates a call graph from the disassembled binary, and generates control flow graphs for each function in the call graph (step 315 ).
- the remainder of the processing can be performed independent of the particular language, operating system, or architecture that the code was written for.
- Next processor 205 calculates the total number of blocks within the selected function's control flow graph (step 330 ), and finally processor 205 calculates the total number of edges within the selected function's control flow graph (step 335 ).
- the edges in the control flow graph are the connections between the different blocks within this graph.
- first processor 205 calculates the leading Eigenvector of the adjacency matrix (step 340 ).
- the adjacency matrix is comprised of the function coordinates 620 (described below in connection with FIG. 6 ).
- processor 205 calculates the Markov chain (step 345 ).
- the Markov chain is calculated starting with the leading Eigenvector and then appending connected nodes corresponding with successively smaller elements of the leading Eigenvector.
- the Markov chain provides a good low-rank approximation, or serialization, of the control flow graph that is relatively unique and particularly well-suited for further statistical analysis of the control flow graph.
- Processor 205 then calculates count block size, in-degree, and out-degree along the Markov chain (step 350 ). These three spectra are relatively unique among and within compiled computer binaries.
- the block count spectrum would be [12, 2, 3, 3, 9] because block 505 has 12 instructions, block 515 has two instructions, blocks 550 and 560 each have three instructions, and block 565 has nine instructions.
- processor 205 determines whether there are any further functions to process (step 355 ). If there are (“Yes” path out of decision step 355 ), then the next function is selected (step 360 ) and the parallel processing is repeated. If not (“No” path out of decision step 355 ), then processor 205 generates the fingerprint of the binary using the calculated information (step 365 ).
- FIG. 6 is a block diagram of an exemplary fingerprint in accordance with the present invention.
- the fingerprint includes bulk file characteristics and meta-data 610 , function coordinates 620 , and unique spectra 630 .
- the function coordinates 620 includes, for each function, the calculated out-degree, number of blocks, and number of edges.
- the unique spectra includes, for each function, the calculated block size, in-degree, and out-degree.
- FIGS. 7A and 7B are flow diagrams of an exemplary process for matching fingerprints in accordance with the present invention. This process is performed using the system of FIG. 2 .
- processor 205 receives two fingerprints of compiled computer binaries via input 215 and/or memory 210 (step 705 ) and compares their bulk file characteristic and meta-data (step 710 ).
- the bulk file characteristic can include measuring the Jaccard Similarity, which is a numerical score representing the amount of overlap between strings contained in both fingerprints, and is typically between 0 and 1.
- processor 205 computes distances between each pair of possible functions of the two fingerprints using the function coordinates 620 of the respective fingerprints (step 720 ).
- Processor 205 sorts the distances (step 720 ) and discards function pairs having distances greater than a threshold distance (step 725 ). This step reduces the processing load because only the most-likely related functions will have distances below the threshold.
- the particular threshold value can be selected depending upon the available processing power of the computer and the desired run-time of the fingerprint comparison process.
- those skilled in the art will recognize that above a certain distance it is highly unlikely that functions will be related, and thus at least some thresholding should be performed to reduce unnecessary processing.
- the comparison score is generated by comparing the selected maximum ratio of the unique spectra ratios to a threshold, and accordingly infringement is identified when the selected maximum ratio is above the threshold.
- the threshold can be set, for example, by training the system using known data and a particular compiled computer binary for which it is to be determined whether there are other compiled computer binaries infringing the particular compiled computer binary. This training identifies commonalities between the known data and the particular compiled computer binary so that the threshold can be set to avoid false positives indicating infringement due to code commonly used across different pieces of software that would not be an indicator of infringement.
- processor 205 can notify the owner of one of the compiled computer binaries of the potential infringement via output 220 (step 790 ).
- the notification can include details of the regions of the allegedly infringing computer binary that is most likely involved in the infringement.
- the collection of compiled computer binaries, fingerprint generation, and fingerprint matching can be automated and scheduled to execute using any type of task scheduling technique.
- the present invention provides a particularly cost- and time-effective way to discover, remediate, and enforce intellectual property rights, and accordingly acts as a deterrence against the theft of software code. Further, by identifying infringement based on the functions contained within compiled computer binaries, the present invention can identify an entirely copied compiled computer binary, as well as copied portions of a compiled computer binary.
- FIG. 8 is a flow diagram of an exemplary fingerprinting technique 800 in accordance with another embodiment of the present invention, which is performed using the system of FIG. 2 .
- processor 205 receives a binary via input 215 and/or memory 210 (step 805 ) and disassembles the binary in order to generate a control flow graph for each function in the binary (step 810 ).
- Processor 205 selects a control flow graph for a first function (step 815 ), reverses all of the edges of the selected control flow graph and performs a block rank algorithm on the selected control flow graph in order to generate a block rank score for each block in the control flow graph of the selected function (step 820 ).
- the block rank algorithm is similar to the PageRank algorithm disclosed in the article “The PageRank Citation Ranking: Bringing Order to the Web” by L. Page et al. 1999, the entire disclosure of which is herein expressly incorporated by reference.
- PageRank the blocks are web pages and the relative importance is based on the number of forward links from the page, as well as the relative importance of the web pages associated with these forward links.
- the blocks within a function and the relative importance of the blocks is based on the number of incoming edges (because the edges are reversed), as well as the relative importance of the blocks from which the incoming edges originate.
- block 906 has a block rank score of 3 because block 916 has only a single forward path and therefore contributes its entire block rank score of 2 and block 914 has a block rank score of 2, which is divided between blocks 904 and 906 .
- Block 904 has forward links from blocks 908 , 910 , and 912 , each of which have only a single forward path and each having a block rank score of 1, and a forward link from block 914 , which splits its block rank score between blocks 904 and 906 .
- block 904 is assigned a value of 4.
- block 902 is assigned a block rank score of 7 because blocks 904 and 906 only have a single forward path, and therefore contribute their entire respective block rank scores of 4 and 3.
- processor 205 begins path construction at the function start (step 825 ) and identifies the blocks connected to the function start in the control flow graph and the block rank score for each connected block (step 830 ). Processor 205 then constructs the path to a next block by selecting the one of the identified blocks having a highest block rank score (step 835 ). When there is more than one of the identified blocks having the same highest block rank score then the block with the larger number of instructions is selected as the next block. If there is still a tie, an arbitrary block is chosen among the blocks having the same highest block rank score.
- FIG. 8 involves fingerprinting functions of a single set of code it should be recognized that this can be performed on additional sets of code so that the fingerprint database is populated with functions from more than one set of code.
- a software developer could fingerprint all of its code so that the database can later be used to identify copied functions from third-party code.
- an entity can offer a service in which code from one or more software developers is collected, for example, by a web spider as described above, is stored in the database and a software developer can bring its code to the entity to determine whether the database includes any code containing copied functions.
- Neighborhood_Size Eclidean_distance([0,0,0], coordinate_triple_of_query_function)*0.20.
- Each cell of the array is assigned a value of “1” if there is a match between the 3-tuples for the query fingerprint and the selected neighborhood fingerprint and a “0” if there is no match.
- the array allows a representation of every possible comparison between the blocks of the two fingerprints by generating pathways through the array and the pathway having the sum of assigned cell values that is the largest is selected as the similarity score.
- processor 205 determines whether the evaluated cell is the last cell in a row (step 1022 ). If not (“No” path out of decision step 1022 ), processor 205 increments the column index by one (step 1024 ) and the next cell in the row is subjected to the successive summation (step 1020 ). If processor 205 determines that the evaluated cell is the last cell of the row (“Yes” path out of decision step 1022 ), then processor 205 determines whether the evaluated cell is the last cell of all of the rows (step 1026 ).
- processor 205 determines there are remaining rows (“No” path of decision step 1026 ), then processor 205 increments the row index by one and resets the column index to the most right-hand column index (step 1028 ) and processor 205 continues the successive summation in the first column of the next row (step 1020 ). The result of the successive summation across all cells is illustrated in FIG. 11C .
- processor 205 determines that all cells have been evaluated (“Yes” path out of decision step 1026 ), then processor 205 selects, based on the Manhattan distance between each of the 3-tuples, a pathway having the largest sum of the assigned cell values, less any gap penalty, as the maximum match pathway (step 1030 ).
- the gap penalty is 3.
- the value in each cell in the outer row or outer column contains a value of the maximum number of matches that can be obtained by starting a pathway at that cell, and the cell in the outer row and column are evaluated identify the cell having the largest value, which is where the maximum match pathway begins. The maximum match pathway then continues from this outer cell to the cell in each successive row or column having a largest value.
- processor 205 determines that all neighborhood functions have been subject to the comparison (“No” path out of decision step 1034 ), then processor 205 identifies any function having a similarity score greater than or equal to a threshold similarity score as being a function having code copied by the query function (step 1038 ).
- the threshold can be set, for example, by training the system using known data and a particular compiled computer binary for which it is to be determined whether there are other compiled computer binaries infringing the particular compiled computer binary. This training identifies commonalities between the known data and the particular compiled computer binary so that the threshold can be set to avoid false positives indicating infringement due to code commonly used across different pieces of software that would not be an indicator of infringement.
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
Description
- This application claims the benefit of Provisional Application 62/138,543, filed Mar. 26, 2015, the entire disclosure of which is herein expressly incorporated by reference. This application is related to Provisional Application 61/973,125, filed Mar. 31, 2014, U.S. Non-Provisional application Ser. No. 14/314,307, filed Jun. 25, 2014, and U.S. Non-Provisional application Ser. No. 14/621,554, filed Feb. 13, 2015, the entire disclosures of which are herein expressly incorporated by reference.
- Software theft has been, and continues to be, pervasive. Individuals and companies typically try various techniques to combat software theft, including requiring a unique software key to install software, requiring online activation of software, requiring an active online connection to use software, encryption of software, and the like. Although these techniques typically prevent casual users from installing unauthorized copies, the techniques can typically be overcome by sophisticated users.
- Another way to combat software theft is to try to identify the source of the stolen software using watermarks. This involves applying unique watermarks to each copy of the software so that when a stolen piece of software is found, the watermark in the stolen software will corresponding to one of the unique watermarks in the authorized software. This requires modification of the computer code, which is undesirable. Further, this technique can be overcome by removing the watermark from the stolen software or removing the watermark from the authorized software so that all further copies do not contain the unique watermark.
- In addition to the issues identified above with the known techniques for combating software theft, these techniques focus on the software as a whole, and thus cannot identify when only portions of the underlying code are stolen. For example, if a watermark were applied to the software, the watermark would not appear in the stolen software if less than the entire code were used. Similarly, if software theft were identified by comparing hash values generated from the authorized and stolen software, the hash values would not match when less than the entire underlying code is present in the stolen software. Thus, a thief could simply modify some portion of the code to defeat these techniques. Further, it is often the case that only a portion of the underlying code is truly unique and provides the overall value to the software, and accordingly a thief may only want to use this unique portion in different software. For example, a thief could copy one or several functions from someone else's software and incorporate the function(s) in his/her own software. Because these functions may comprise only a small part of the overall code in the thief's software, simple watermarking and hash value techniques across an entire set of code would not identify this theft of several functions from someone else's code.
- Exemplary embodiments of the present invention are directed to techniques for combating software theft by identifying whether at least a portion of one piece of software appears in another piece of software. Thus, the present invention allows the identification of whether portions of one piece of software appear in a different piece of software, even when the overall operation of the two pieces of software is different. The inventive technique is particularly useful because it operates using compiled computer binaries, and thus does not require access to the underlying source code.
- In accordance with exemplary embodiments of the present invention, fingerprints are generated for functions in compiled computer binaries. The fingerprint generation involves generating a block rank score for each block of a function and then generating order list of blocks in a path through the function using the block rank scores. The comparison of fingerprints involves the use of the ordered list of blocks for each corresponding function to identify similarities between the fingerprints.
-
FIG. 1 is a flow diagram of the overall process of exemplary embodiments of the present invention; -
FIG. 2 is a block diagram of an exemplary system for generating and matching fingerprints in accordance with the present invention; -
FIG. 3 is a flow diagram of an exemplary process for generating a fingerprint using binary code in accordance with the present invention; -
FIG. 4 is a block diagram of an exemplary call graph in accordance with the present invention; -
FIG. 5 is a block diagram of an exemplary control flow graph in accordance with the present invention; -
FIG. 6 is a block diagram of an exemplary fingerprint in accordance with the present invention; -
FIGS. 7A and 7B are flow diagrams of an exemplary process for matching fingerprints in accordance with the present invention; -
FIG. 8 is a flow diagram of an exemplary fingerprinting technique in accordance with another embodiment of the present invention; -
FIG. 9 is a block diagram illustrating application of block ranking to an exemplary function in accordance with the present invention; -
FIGS. 10A and 10B are flow diagrams of an exemplary process for matching fingerprints in accordance with another embodiment of the present invention; and -
FIGS. 11A-11C are block diagrams illustrating exemplary arrays used for calculating fingerprint similarity scores in accordance with the present invention. -
FIG. 1 is a flow diagram of the overall process of exemplary embodiments of the present invention. As illustrated inFIG. 1 , the overall process involves generating a fingerprint from compiled computer binaries (step 300 or 800) and matching the generated fingerprints to determine whether there is sufficient similarity (step 700 or 1000). It should be recognized that fingerprint generation from compiled computer binaries that are later compared for matching can be performed at approximately the same time or can be performed at different times. For example, a fingerprint of a first compiled computer binary can be generated for purposes of identifying theft of the underlying code. Other compiled computer binaries can then be collected over a period of time, and then fingerprints can be generated using the other compiled computer binaries for comparison with the first compiled computer binaries. These other compiled computer binaries can be obtained in any manner, such as, for example, using a web spider that crawls across the Internet and collects compiled computer binaries. The other compiled computer binaries can also be manually input. For example, the owner of a first compiled computer binary may suspect that a second compiled computer binary contains code stolen from the first compiled computer binary. In this case, the fingerprints can be generated from the first and second compiled computer binaries at approximately the same time and then compared using the inventive fingerprint matching technique. -
FIG. 2 is a block diagram of an exemplary system for generating and matching fingerprints in accordance with the present invention. Thesystem 200 can comprise one or more computers that include aprocessor 205 coupled tomemory 210,input 215, andoutput 220. The disclosed processes can be performed byprocessor 205 executing computer code stored inmemory 210.Processor 205 can be any type of processor, including a microprocessor, field programmable gate array (FPGA), and/or an application specific integrated circuit (ASIC).Memory 210 can be any type of non-transitory memory. In addition to storing computer code for executing the processes described herein,memory 210 can also store the generated fingerprints. Alternatively or additionally, a separate storage medium can store the generated fingerprints. For example, the computer binaries, fingerprints, and comparison scores can be stored in a distributed file system and non-relational, distributed database.Input 215 provides mechanisms for controlling the disclosed processes, including, for example, a keyboard, mouse, trackball, trackpad, touchscreen, etc. Further,input 215 can include a connection to an external storage device for providing compiled computer binaries, such as an external hard drive or flash storage memory, as well as a network connection.Output 220 can include a display, printer, and/or the like. Additionally,output 220 can include a network connection for notifying an owner of a compiled computer binary of any identified potential infringement, such as by electronic mail, posting on a website or webpage, a text message, and/or the like. -
FIG. 3 is a flow diagram of an exemplary process for generating a fingerprint using binary code in accordance with the present invention. This process is performed using the system ofFIG. 2 . Initially,processor 205 receives a compiled computer binary (step 305) viainput 215 and/ormemory 210 and measures bulk file characteristics and meta-data (step 310). Next,processor 205 disassembles the compiled computer binary, generates a call graph from the disassembled binary, and generates control flow graphs for each function in the call graph (step 315). Once the compiled computer binary is disassembled, the remainder of the processing can be performed independent of the particular language, operating system, or architecture that the code was written for. -
FIG. 4 is a block diagram of an exemplary call graph in accordance with the present invention. As will be appreciated by those skilled in the art, a call graph describes the relationship between various functions in a compiled binary. Thus, inFIG. 4 , a main function 405 (also commonly referred to as a routine) has calls to sub-functions 410 and 415 (also commonly referred to as sub-routines). In turn, function 415 has calls tofunctions functions FIG. 4 is a highly simplified graph and that compiled computer binaries typically will be disassembled into much more extensive call graphs. -
FIG. 5 is a block diagram of an exemplary control flow graph in accordance with the present invention. Those skilled in the art will recognize that a control flow graph for a function describes all possible paths that may be traversed during execution of the particular function. Examples of paths that may be executed in the function ofFIG. 5 includeblocks FIG. 5 can be traversed during the execution of the function. Further, it should be recognized that this is merely an exemplary function and that other functions are within the scope of the invention. - Returning to
FIG. 3 , afterprocessor 205 generates the control flow graphs for each function (step 315),processor 205 selects one of the functions for processing (step 320). As illustrated, this processing is performed along two parallel paths. It should be recognized, however, that these two paths can be performed serially, if desired. It should also be recognized that this parallel processing does not require all of the control flow graphs to be generated, and accordingly this parallel processing can be performed as control flow graphs are generated. Turning to the path on the left-hand side ofFIG. 3 ,first processor 205 calculates the function out-degree using the call graph for the particular function (step 325). The function out-degree represents the number of paths or calls from a particular function to other functions in the call graph.Next processor 205 calculates the total number of blocks within the selected function's control flow graph (step 330), and finallyprocessor 205 calculates the total number of edges within the selected function's control flow graph (step 335). The edges in the control flow graph are the connections between the different blocks within this graph. - Turning now to the path on the right-hand side of
FIG. 3 ,first processor 205 calculates the leading Eigenvector of the adjacency matrix (step 340). The adjacency matrix is comprised of the function coordinates 620 (described below in connection withFIG. 6 ). Next,processor 205 calculates the Markov chain (step 345). The Markov chain is calculated starting with the leading Eigenvector and then appending connected nodes corresponding with successively smaller elements of the leading Eigenvector. The Markov chain provides a good low-rank approximation, or serialization, of the control flow graph that is relatively unique and particularly well-suited for further statistical analysis of the control flow graph. -
Processor 205 then calculates count block size, in-degree, and out-degree along the Markov chain (step 350). These three spectra are relatively unique among and within compiled computer binaries. An example of the count block size, in-degree, and out-degree will now be described in connection withFIG. 5 , and assuming a chain between the blocks as follows: 505=>515=>550=>560=>565. In this example the block count spectrum would be [12, 2, 3, 3, 9] becauseblock 505 has 12 instructions, block 515 has two instructions, blocks 550 and 560 each have three instructions, and block 565 has nine instructions. The in-degree spectrum would be [0, 2, 3, 1, 2] becauseblock 505 does not have any incoming edges, block 515 has two incoming edges, block 550 has three incoming edges, block 560 has one incoming edge, and block 565 has two incoming edges. The out-degree spectrum would be [2, 2, 2, 1, 1] becauseblocks - After the processing of the two parallel paths is complete,
processor 205 determines whether there are any further functions to process (step 355). If there are (“Yes” path out of decision step 355), then the next function is selected (step 360) and the parallel processing is repeated. If not (“No” path out of decision step 355), thenprocessor 205 generates the fingerprint of the binary using the calculated information (step 365). -
FIG. 6 is a block diagram of an exemplary fingerprint in accordance with the present invention. As illustrated inFIG. 6 , the fingerprint includes bulk file characteristics and meta-data 610, function coordinates 620, andunique spectra 630. The function coordinates 620 includes, for each function, the calculated out-degree, number of blocks, and number of edges. The unique spectra includes, for each function, the calculated block size, in-degree, and out-degree. These fingerprints are then used for comparison against fingerprints of other compiled computer binaries as described below in connection withFIGS. 7A and 7B . -
FIGS. 7A and 7B are flow diagrams of an exemplary process for matching fingerprints in accordance with the present invention. This process is performed using the system ofFIG. 2 . Initially,processor 205 receives two fingerprints of compiled computer binaries viainput 215 and/or memory 210 (step 705) and compares their bulk file characteristic and meta-data (step 710). The bulk file characteristic can include measuring the Jaccard Similarity, which is a numerical score representing the amount of overlap between strings contained in both fingerprints, and is typically between 0 and 1. - Next,
processor 205 computes distances between each pair of possible functions of the two fingerprints using the function coordinates 620 of the respective fingerprints (step 720).Processor 205 then sorts the distances (step 720) and discards function pairs having distances greater than a threshold distance (step 725). This step reduces the processing load because only the most-likely related functions will have distances below the threshold. Thus, the particular threshold value can be selected depending upon the available processing power of the computer and the desired run-time of the fingerprint comparison process. Furthermore, those skilled in the art will recognize that above a certain distance it is highly unlikely that functions will be related, and thus at least some thresholding should be performed to reduce unnecessary processing. -
Processor 205 then generates a list using the remaining function pairs (step 730), and one of the function pairs from the reduced list is selected for further processing of the unique spectra 630 (step 735). Specifically,processor 205 calculates a cross-correlation for the block-size spectra (step 740), the in-degree spectra (step 745), and the out-degree spectra (step 750). It will be recognized that the cross-correlation is a measure of how closely the spectra of the two fingerprints are related.Next processor 205 determines whether any function pairs remain to be processed (step 755). If so (“Yes path out of decision step 755), then the next function pair is selected from the reduced list (step 735) and the cross-correlation of the unique spectra are calculated (steps 740-750). The cross-correlation can produce a correlation coefficient indicating the degree of similarity or correlation. For example, a coefficient of −1 indicates complete anti-correlation and 1 indicates complete correlation (i.e., the two fingerprints have the same control flow graph). - If there are no remaining function pairs to process (“No” path out of decision step 755), then
processor 205 calculates a block-size, in-degree and out-degree spectra ratios (step 760-770). These ratios are calculated by dividing a total number of respective correlation coefficients above a threshold by a total number of correlation coefficients. The threshold used for the calculation of the three ratios can be the same or different.Processor 205 then selects the maximum ratio of the unique spectra ratios (step 775) and generates a comparison score based on the selected maximum ratio (step 780). The generated comparison score is then used byprocessor 205 to identify infringement of one of the compiled computer binaries (step 785). The comparison score is generated by comparing the selected maximum ratio of the unique spectra ratios to a threshold, and accordingly infringement is identified when the selected maximum ratio is above the threshold. The threshold can be set, for example, by training the system using known data and a particular compiled computer binary for which it is to be determined whether there are other compiled computer binaries infringing the particular compiled computer binary. This training identifies commonalities between the known data and the particular compiled computer binary so that the threshold can be set to avoid false positives indicating infringement due to code commonly used across different pieces of software that would not be an indicator of infringement. - When, based on the generated comparison score, there is sufficient similarity between the compiled computer binaries or portions of the compiled computer binaries,
processor 205 can notify the owner of one of the compiled computer binaries of the potential infringement via output 220 (step 790). The notification can include details of the regions of the allegedly infringing computer binary that is most likely involved in the infringement. - The collection of compiled computer binaries, fingerprint generation, and fingerprint matching can be automated and scheduled to execute using any type of task scheduling technique. Thus, the present invention provides a particularly cost- and time-effective way to discover, remediate, and enforce intellectual property rights, and accordingly acts as a deterrence against the theft of software code. Further, by identifying infringement based on the functions contained within compiled computer binaries, the present invention can identify an entirely copied compiled computer binary, as well as copied portions of a compiled computer binary.
-
FIG. 8 is a flow diagram of anexemplary fingerprinting technique 800 in accordance with another embodiment of the present invention, which is performed using the system ofFIG. 2 . Initially,processor 205 receives a binary viainput 215 and/or memory 210 (step 805) and disassembles the binary in order to generate a control flow graph for each function in the binary (step 810).Processor 205 selects a control flow graph for a first function (step 815), reverses all of the edges of the selected control flow graph and performs a block rank algorithm on the selected control flow graph in order to generate a block rank score for each block in the control flow graph of the selected function (step 820). The block rank algorithm is similar to the PageRank algorithm disclosed in the article “The PageRank Citation Ranking: Bringing Order to the Web” by L. Page et al. 1999, the entire disclosure of which is herein expressly incorporated by reference. Those skilled in the art will recognize that the PageRank algorithm is a type of Eigenvector centrality algorithm that assigns a value corresponding to the relative importance of each block in a graph. In PageRank the blocks are web pages and the relative importance is based on the number of forward links from the page, as well as the relative importance of the web pages associated with these forward links. In the present invention the blocks within a function and the relative importance of the blocks is based on the number of incoming edges (because the edges are reversed), as well as the relative importance of the blocks from which the incoming edges originate. - The application of block rank scoring to an exemplary, simplified function is illustrated in
FIG. 9 , which illustrates a function with the edges reversed going from the end of the function to the start. In thisexemplary function block 906 has a block rank score of 3 becauseblock 916 has only a single forward path and therefore contributes its entire block rank score of 2 and block 914 has a block rank score of 2, which is divided betweenblocks Block 904 has forward links fromblocks block 914, which splits its block rank score betweenblocks blocks - Once a relative importance value is assigned to each block within the control flow graph for the first function, a path is constructed starting from the function start based on the block rank score. Specifically,
processor 205 begins path construction at the function start (step 825) and identifies the blocks connected to the function start in the control flow graph and the block rank score for each connected block (step 830).Processor 205 then constructs the path to a next block by selecting the one of the identified blocks having a highest block rank score (step 835). When there is more than one of the identified blocks having the same highest block rank score then the block with the larger number of instructions is selected as the next block. If there is still a tie, an arbitrary block is chosen among the blocks having the same highest block rank score. - For each selected block in the
path processor 205 saves a 3-tuple inmemory 210 as an ordered list based on the order of the blocks in the path (step 840). The 3-tuple comprises the number of instructions in the block, the in-degree of the block, and the out-degree of the block.Next processor 205 determines whether there are any out paths from the selected block (step 845). When processor determines there are out paths (“Yes” path out of decision step 845) thenprocessor 205 uses the block rank score to select a next connected block (step 835). - The path construction continues until a block is reached that does not have any out paths (“No” path out of decision step 845). Once the end block is reached
processor 205 generates the fingerprint of the selected function by storing the ordered list of 3-tuples inmemory 210 along with the control flow graph block count, the control flow graph edge count, and the function call count (step 850). Each element of the ordered list corresponds to each block along the chosen characteristic path (or the Markov chain referred to above). - Returning to the exemplary function of
FIG. 9 , the path would be constructed fromblock 902 to block 904 becauseblock 904 has a higher block rank value thanblock 906. The path would then continue fromblock 904 to block 914 becauseblock 914 has the highest block rank value of any of the outgoing paths fromblock 904. Thus, it should be appreciated that the ordered list does not include all blocks of the function, only those along the path. Accordingly, this reduces the amount of information required to generate a fingerprint, and in turn improves the overall functioning of a computer executing this method because the overall processing power is reduced. - Returning to
FIG. 8 ,next processor 205 determines whether there are any remaining functions in the binary that have not yet been processed (step 855). Ifprocessor 205 determines there are any remaining functions (“Yes” path out of decision step 855),processor 205 selects a next function (step 860) and the function is processed in the same manner as the first selected function (steps 820-850). Whenprocessor 205 has processed all functions of the binary (“No” path out of decision step 855) the fingerprints of each of the functions are saved inmemory 210 along with an association with the received binary from which the functions originated (step 865). - Although
FIG. 8 involves fingerprinting functions of a single set of code it should be recognized that this can be performed on additional sets of code so that the fingerprint database is populated with functions from more than one set of code. For example, a software developer could fingerprint all of its code so that the database can later be used to identify copied functions from third-party code. Similarly, an entity can offer a service in which code from one or more software developers is collected, for example, by a web spider as described above, is stored in the database and a software developer can bring its code to the entity to determine whether the database includes any code containing copied functions. -
FIGS. 10A and 10B are a flow diagrams of anexemplary process 1000 for matching fingerprints in accordance with another embodiment of the present invention, which is performed using the system ofFIG. 2 . Because the database of fingerprinted functions is generated using disassembled complied binaries the fingerprinted functions may contain one or more blocks that are added by the complier during compilation of the source code. Accordingly, a function may have been copied from another function even though two functions are not identical, i.e., there may not be an exact correspondence between the blocks and/or paths of one function and those of another function. These types of discrepancies are addressed in the method ofFIGS. 10A and 10B , and thus the fingerprint matching of the present invention can identify functions containing copied code even when the functions are not identical. - Accordingly, when one desires to determine whether a function has been copied,
processor 205 receives the function as a query function (step 1002) and fingerprints it (step 1004) using the method detailed above in connection withFIG. 8 .Next processor 205 determines a neighborhood size for identifying potentially copied functions (step 1006) using the following formula: -
Neighborhood_Size=Eclidean_distance([0,0,0], coordinate_triple_of_query_function)*0.20. - where coordinate_triple_of_query_function comprises the (1) control flow graph block count, (2) control flow graph edge count, and (3) function call count of the query function.
- The value 0.20 is a weighting factor controlling the size of the neighborhood, which in this instance is a 20% weighting factor. It should be recognized that other weighting factors could be employed, as well as no weighting factor, depending upon the query function. The weighting factor adjustment depends on the density of the distribution of the measurements of the function features, specifically, how many other functions within the call graph have similar feature metrics necessitating an expansion or contraction of the definition of a function's neighborhood.
- Now that the search neighborhood has been defined,
processor 205 can search a database of fingerprints, which can be stored inmemory 210, to identify those within the search neighborhood and then select the fingerprint of a first function in the neighborhood (step 1008). Processor then initiates a comparison of the selected neighborhood fingerprint corresponding 3-tuple to the 3-tuple of the fingerprint of the query function (step 1010).Processor 205 begins the comparison by independently normalizing each dimension of the query fingerprint and the selected neighborhood fingerprint by dividing the distance from the mean for each dimension of all fingerprints in the neighborhood by the standard deviation for each dimension of all fingerprints in the neighborhood (step 1012). -
Processor 205 calculates a similarity score between the query fingerprint and the selected neighborhood fingerprint using the Needleman-Wunsch algorithm (step 1014), which is described in the article “A general method applicable to the search for similarities in the amino acid sequence of two proteins” S. Needleman et al., Journal of Molecular Biology 48 (3): 443-53. doi:10.1016/0022-2836 (70)90057-4. PMID 5420325, the entire disclosure of which is herein expressly incorporated by reference. - The details of the application of the Needleman-Wunsch algorithm in the present invention are illustrated in
FIG. 10B , which will be described in connection withFIGS. 11A-11C . First,processor 205 generates a two-dimensional array Aj×Bi of all possible pair combinations of 3-tuples between the query fingerprint and the selected neighborhood fingerprint (step 1016), where, starting from the beginning of the ordered list of 3-tuples, Aj represents jth block in the ordered list for the selected neighborhood function the and Bi represents the ith block in the ordered list for the query function. The assignment of the neighborhood function to Aj and the query function to Bi is not critical and the assignments can be reversed. Each cell of the array is assigned a value of “1” if there is a match between the 3-tuples for the query fingerprint and the selected neighborhood fingerprint and a “0” if there is no match. The array allows a representation of every possible comparison between the blocks of the two fingerprints by generating pathways through the array and the pathway having the sum of assigned cell values that is the largest is selected as the similarity score. - Next,
processor 205 initializes the indices i and j to correspond to the last cell in the array (step 1018), which in this example is setting i=y and j=z.Processor 205 then performs a successive summation procedure according to steps 1020-1028, in a row-by-row manner starting from the right side of each row. Specifically, for a cell under evaluation at i=y and j=z,processor 205 adds its value to the maximum value of the cells having indices i=y−1 and/or j=z−1 (step 1020). For example, referring now toFIGS. 11A and 11B , assume that the highlighted cell atindices FIG. 11A the cells inrow 4 to the right of the cell atindices FIG. 11B , the value of 2 is added to the value of 1 already atcell index - Returning to
FIG. 10B , after adding the value to a cell,processor 205 determines whether the evaluated cell is the last cell in a row (step 1022). If not (“No” path out of decision step 1022),processor 205 increments the column index by one (step 1024) and the next cell in the row is subjected to the successive summation (step 1020). Ifprocessor 205 determines that the evaluated cell is the last cell of the row (“Yes” path out of decision step 1022), thenprocessor 205 determines whether the evaluated cell is the last cell of all of the rows (step 1026). Ifprocessor 205 determines there are remaining rows (“No” path of decision step 1026), thenprocessor 205 increments the row index by one and resets the column index to the most right-hand column index (step 1028) andprocessor 205 continues the successive summation in the first column of the next row (step 1020). The result of the successive summation across all cells is illustrated inFIG. 11C . - If
processor 205 determines that all cells have been evaluated (“Yes” path out of decision step 1026), thenprocessor 205 selects, based on the Manhattan distance between each of the 3-tuples, a pathway having the largest sum of the assigned cell values, less any gap penalty, as the maximum match pathway (step 1030). In an exemplary embodiment the gap penalty is 3. However, it will be recognized that other gap penalties can be used. The value in each cell in the outer row or outer column contains a value of the maximum number of matches that can be obtained by starting a pathway at that cell, and the cell in the outer row and column are evaluated identify the cell having the largest value, which is where the maximum match pathway begins. The maximum match pathway then continues from this outer cell to the cell in each successive row or column having a largest value. Referring again toFIG. 11C , the largest number in the outer row or column is atindex index - Returning to
FIG. 10A , onceprocessor 205 identifies the maximum match pathway (step 1030), thenprocessor 205 uses the sum of all of the cells along the pathway as the similarity score, which is added to a similarity score ranking list, which is ordered by score from closest to further (step 1034). Ifprocessor 205 determines there are functions in the neighborhood that have not yet been compared (“Yes” path out of decision step 1034), thenprocessor 205 selects the next neighborhood function (step 1036) and subjects it to the comparison (step 1010). Ifprocessor 205 determines that all neighborhood functions have been subject to the comparison (“No” path out of decision step 1034), thenprocessor 205 identifies any function having a similarity score greater than or equal to a threshold similarity score as being a function having code copied by the query function (step 1038). The threshold can be set, for example, by training the system using known data and a particular compiled computer binary for which it is to be determined whether there are other compiled computer binaries infringing the particular compiled computer binary. This training identifies commonalities between the known data and the particular compiled computer binary so that the threshold can be set to avoid false positives indicating infringement due to code commonly used across different pieces of software that would not be an indicator of infringement. - Although
FIGS. 10A and 10B involve a comparison between the query function and a plurality of functions stored in a database of fingerprints, the comparison technique can also be employed to compare two functions to identify whether one contains copied code of the other. In this case the selection of the neighborhood size (step 1006) could be eliminated along with the iteration through the functions in the neighborhood (the return path fromstep 1036 to 1010). Alternatively, the neighborhood size (step 1006) could be maintained as an initial threshold to quickly eliminate the possibility of copying when one of the fingerprints is outside of the neighborhood. In this case the iteration through functions in the neighborhood would still be eliminated because the comparison involves only two functions. - The fingerprint generation and matching techniques of the present invention advantageously improve the operation of the computer performing these techniques by reducing the processing load required to fingerprint code and compare fingerprints.
- Although exemplary embodiments have been described above as generating fingerprints using compiled computer binaries, the present invention is equally applicable to computer source code, byte code, and the like.
- The foregoing disclosure has been set forth merely to illustrate the invention and is not intended to be limiting. Since modifications of the disclosed embodiments incorporating the spirit and substance of the invention may occur to persons skilled in the art, the invention should be construed to include everything within the scope of the appended claims and equivalents thereof.
Claims (19)
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US15/079,719 US9459861B1 (en) | 2014-03-31 | 2016-03-24 | Systems and methods for detecting copied computer code using fingerprints |
Applications Claiming Priority (5)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US201461973125P | 2014-03-31 | 2014-03-31 | |
US14/314,307 US9417593B2 (en) | 2013-06-28 | 2014-06-25 | Image forming apparatus configured to switch between supplying and shutting-off of power to a portion of the image forming apparatus |
US14/621,554 US9218466B2 (en) | 2014-03-31 | 2015-02-13 | Systems and methods for detecting copied computer code using fingerprints |
US201562138543P | 2015-03-26 | 2015-03-26 | |
US15/079,719 US9459861B1 (en) | 2014-03-31 | 2016-03-24 | Systems and methods for detecting copied computer code using fingerprints |
Publications (2)
Publication Number | Publication Date |
---|---|
US20160283229A1 true US20160283229A1 (en) | 2016-09-29 |
US9459861B1 US9459861B1 (en) | 2016-10-04 |
Family
ID=56975717
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US15/079,719 Active US9459861B1 (en) | 2014-03-31 | 2016-03-24 | Systems and methods for detecting copied computer code using fingerprints |
Country Status (1)
Country | Link |
---|---|
US (1) | US9459861B1 (en) |
Cited By (9)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20160378445A1 (en) * | 2015-06-26 | 2016-12-29 | Mitsubishi Electric Corporation | Similarity determination apparatus, similarity determination method and similarity determination program |
US20180365148A1 (en) * | 2015-12-14 | 2018-12-20 | Dataware Ventures, Llc | Broadening field specialization |
US10346291B2 (en) * | 2017-02-21 | 2019-07-09 | International Business Machines Corporation | Testing web applications using clusters |
WO2020194186A1 (en) * | 2019-03-25 | 2020-10-01 | Aurora Labs Ltd. | Generating and signing a line-of-code behavior and relation model |
US11074062B1 (en) * | 2019-08-14 | 2021-07-27 | Amazon Technologies, Inc. | Neural networks for software patch applicability |
US11099842B2 (en) * | 2019-01-08 | 2021-08-24 | Saudi Arabian Oil Company | Source code similarity detection using digital fingerprints |
US11099843B2 (en) * | 2017-12-29 | 2021-08-24 | Microsoft Technology Licensing, Llc | Determining similarity groupings for software development projects |
US20210279105A1 (en) * | 2017-06-22 | 2021-09-09 | Dataware Ventures, Llc | Field specialization to reduce memory-access stalls and allocation requests in data-intensive applications |
CN115145633A (en) * | 2022-07-25 | 2022-10-04 | 杭州师范大学 | Code error automatic detection method based on control flow graph |
Families Citing this family (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US9851959B2 (en) * | 2016-02-17 | 2017-12-26 | Qualcomm Innovation Center, Inc. | Semantically sensitive code region fingerprint calculation for programming languages |
US11972256B2 (en) | 2022-02-16 | 2024-04-30 | International Business Machines Corporation | Software code analysis using fuzzy fingerprinting |
Family Cites Families (43)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20020009208A1 (en) | 1995-08-09 | 2002-01-24 | Adnan Alattar | Authentication of physical and electronic media objects using digital watermarks |
US5559884A (en) | 1994-06-30 | 1996-09-24 | Microsoft Corporation | Method and system for generating and auditing a signature for a computer program |
US5892900A (en) | 1996-08-30 | 1999-04-06 | Intertrust Technologies Corp. | Systems and methods for secure transaction management and electronic rights protection |
US6157721A (en) | 1996-08-12 | 2000-12-05 | Intertrust Technologies Corp. | Systems and methods using cryptography to protect secure computing environments |
US6000030A (en) | 1996-06-20 | 1999-12-07 | Emc Corporation | Software fingerprinting and branding |
US6381739B1 (en) | 1996-05-15 | 2002-04-30 | Motorola Inc. | Method and apparatus for hierarchical restructuring of computer code |
US7590853B1 (en) | 1996-08-12 | 2009-09-15 | Intertrust Technologies Corporation | Systems and methods using cryptography to protect secure computing environments |
US6108420A (en) | 1997-04-10 | 2000-08-22 | Channelware Inc. | Method and system for networked installation of uniquely customized, authenticable, and traceable software application |
EP0988591A1 (en) | 1997-06-09 | 2000-03-29 | Intertrust, Incorporated | Obfuscation techniques for enhancing software security |
WO1999064973A1 (en) | 1998-06-10 | 1999-12-16 | Auckland Uniservices Limited | Software watermarking techniques |
US6966002B1 (en) | 1999-04-30 | 2005-11-15 | Trymedia Systems, Inc. | Methods and apparatus for secure distribution of software |
US7770016B2 (en) | 1999-07-29 | 2010-08-03 | Intertrust Technologies Corporation | Systems and methods for watermarking software and other media |
US7058941B1 (en) | 2000-11-14 | 2006-06-06 | Microsoft Corporation | Minimum delta generator for program binaries |
US7055008B2 (en) * | 2003-01-22 | 2006-05-30 | Falconstor Software, Inc. | System and method for backing up data |
US7739737B2 (en) | 2003-07-29 | 2010-06-15 | Wisconsin Alumni Research Foundation | Method and apparatus to detect malicious software |
US8661559B2 (en) | 2003-08-18 | 2014-02-25 | Riverside Research Institute | Software control flow watermarking |
CA2585145A1 (en) | 2004-11-04 | 2007-01-04 | Telcordia Technologies, Inc. | Detecting exploit code in network flows |
US8316060B1 (en) | 2005-01-26 | 2012-11-20 | 21st Century Technologies | Segment matching search system and method |
US8056138B2 (en) | 2005-02-26 | 2011-11-08 | International Business Machines Corporation | System, method, and service for detecting improper manipulation of an application |
US8046834B2 (en) | 2005-03-30 | 2011-10-25 | Alcatel Lucent | Method of polymorphic detection |
US20080134326A2 (en) | 2005-09-13 | 2008-06-05 | Cloudmark, Inc. | Signature for Executable Code |
US8176568B2 (en) | 2005-12-30 | 2012-05-08 | International Business Machines Corporation | Tracing traitor coalitions and preventing piracy of digital content in a broadcast encryption system |
US20070239993A1 (en) | 2006-03-17 | 2007-10-11 | The Trustees Of The University Of Pennsylvania | System and method for comparing similarity of computer programs |
KR100797024B1 (en) | 2006-05-02 | 2008-01-22 | 한국전자통신연구원 | Method and apparatus for hybrid image watermarking |
US8214497B2 (en) | 2007-01-24 | 2012-07-03 | Mcafee, Inc. | Multi-dimensional reputation scoring |
US8131998B2 (en) * | 2007-03-05 | 2012-03-06 | George Mason Intellectual Properties, Inc. | Transparent authentication of continuous data streams |
US20100011441A1 (en) | 2007-05-01 | 2010-01-14 | Mihai Christodorescu | System for malware normalization and detection |
US7912894B2 (en) | 2007-05-15 | 2011-03-22 | Adams Phillip M | Computerized, copy-detection and discrimination apparatus and method |
EP2223256A1 (en) | 2007-11-17 | 2010-09-01 | Uniloc Usa, Inc. | System and method for adjustable licensing of digital products |
KR100960120B1 (en) | 2007-12-17 | 2010-05-27 | 한국전자통신연구원 | Signature String Storing Memory Structure and the Storing Method for the Same, Signature String Pattern Matching Method |
US8869103B2 (en) | 2008-10-06 | 2014-10-21 | The Mathworks, Inc. | Using intermediate representations to verify computer-executable code generated from a model |
US8533848B2 (en) | 2009-02-18 | 2013-09-10 | Korea Advanced Institute Of Science And Technology | Method and system for producing multimedia fingerprint based on quantum hashing |
US9110769B2 (en) | 2010-04-01 | 2015-08-18 | Microsoft Technology Licensing, Llc | Code-clone detection and analysis |
CN102012862A (en) | 2010-11-09 | 2011-04-13 | 北京神舟航天软件技术有限公司 | Verification method of compiler based on contrast of logical structures of control flow graphs |
US8666999B2 (en) | 2011-08-02 | 2014-03-04 | Rockwell Automation Technologies, Inc. | Search utility program for software developers |
US8825689B2 (en) * | 2012-05-21 | 2014-09-02 | Sonatype, Inc. | Method and system for matching unknown software component to known software component |
US20120317421A1 (en) | 2012-06-19 | 2012-12-13 | Concurix Corporation | Fingerprinting Executable Code |
US9003529B2 (en) | 2012-08-29 | 2015-04-07 | The Johns Hopkins University | Apparatus and method for identifying related code variants in binaries |
US9111095B2 (en) | 2012-08-29 | 2015-08-18 | The Johns Hopkins University | Apparatus and method for identifying similarity via dynamic decimation of token sequence n-grams |
US9740868B2 (en) | 2012-09-27 | 2017-08-22 | International Business Machines Corporation | Customizing a security report using static analysis |
US9438620B2 (en) | 2013-10-22 | 2016-09-06 | Mcafee, Inc. | Control flow graph representation and classification |
US10747880B2 (en) | 2013-12-30 | 2020-08-18 | University Of Louisiana At Lafayette | System and method for identifying and comparing code by semantic abstractions |
US8997256B1 (en) | 2014-03-31 | 2015-03-31 | Terbium Labs LLC | Systems and methods for detecting copied computer code using fingerprints |
-
2016
- 2016-03-24 US US15/079,719 patent/US9459861B1/en active Active
Cited By (41)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20160378445A1 (en) * | 2015-06-26 | 2016-12-29 | Mitsubishi Electric Corporation | Similarity determination apparatus, similarity determination method and similarity determination program |
US20180365148A1 (en) * | 2015-12-14 | 2018-12-20 | Dataware Ventures, Llc | Broadening field specialization |
US10733099B2 (en) * | 2015-12-14 | 2020-08-04 | Arizona Board Of Regents On Behalf Of The University Of Arizona | Broadening field specialization |
US10346291B2 (en) * | 2017-02-21 | 2019-07-09 | International Business Machines Corporation | Testing web applications using clusters |
US10592399B2 (en) | 2017-02-21 | 2020-03-17 | International Business Machines Corporation | Testing web applications using clusters |
US20210279105A1 (en) * | 2017-06-22 | 2021-09-09 | Dataware Ventures, Llc | Field specialization to reduce memory-access stalls and allocation requests in data-intensive applications |
US11099843B2 (en) * | 2017-12-29 | 2021-08-24 | Microsoft Technology Licensing, Llc | Determining similarity groupings for software development projects |
US11099842B2 (en) * | 2019-01-08 | 2021-08-24 | Saudi Arabian Oil Company | Source code similarity detection using digital fingerprints |
US11216360B2 (en) | 2019-03-25 | 2022-01-04 | Aurora Labs Ltd. | Identifying software dependencies using controller code models |
US11347632B2 (en) * | 2019-03-25 | 2022-05-31 | Aurora Labs Ltd. | Generating and signing a line-of-code behavior and relation model |
US10963373B2 (en) | 2019-03-25 | 2021-03-30 | Aurora Labs Ltd. | Identifying software dependencies using line-of-code behavior and relation models |
US11074167B2 (en) | 2019-03-25 | 2021-07-27 | Aurora Labs Ltd. | Visualization of code execution through line-of-code behavior and relation models |
US11960807B2 (en) | 2019-03-25 | 2024-04-16 | Aurora Labs Ltd. | Proving whether software functionality has changed following a software change |
US11074168B2 (en) | 2019-03-25 | 2021-07-27 | Aurora Labs Ltd. | Equivalency determinations using symbol-based line-of-code behavior and relation models |
US11086770B2 (en) * | 2019-03-25 | 2021-08-10 | Aurora Labs Ltd. | Generating and signing a line-of-code behavior and relation model |
US11086769B2 (en) | 2019-03-25 | 2021-08-10 | Aurora Labs Ltd. | Proving whether software functionality has changed following a software change |
US10896038B2 (en) | 2019-03-25 | 2021-01-19 | Aurora Labs Ltd. | Generating and signing a line-of-code behavior and relation model |
US10884898B2 (en) | 2019-03-25 | 2021-01-05 | Aurora Labs Ltd. | Verifying software malfunction sources among disparate code sources |
US10878082B2 (en) | 2019-03-25 | 2020-12-29 | Aurora Labs Ltd. | Dynamic CFI using line-of-code behavior and relation models |
US11144444B2 (en) | 2019-03-25 | 2021-10-12 | Aurora Labs Ltd. | Identifying software interdependencies using line-of-code behavior and relation models |
WO2020194186A1 (en) * | 2019-03-25 | 2020-10-01 | Aurora Labs Ltd. | Generating and signing a line-of-code behavior and relation model |
US11216359B2 (en) | 2019-03-25 | 2022-01-04 | Aurora Labs Ltd. | Verifying software malfunction sources among disparate code sources |
US11263121B2 (en) | 2019-03-25 | 2022-03-01 | Aurora Labs Ltd. | Visualization of code execution through line-of-code behavior and relation models |
US11269762B2 (en) | 2019-03-25 | 2022-03-08 | Aurora Labs Ltd. | Using line-of-code behavior and relation models to anticipate impact of hardware changes |
US11314633B2 (en) | 2019-03-25 | 2022-04-26 | Aurora Labs Ltd. | Dynamic CFI using line-of-code behavior and relation models |
US10922218B2 (en) | 2019-03-25 | 2021-02-16 | Aurora Labs Ltd. | Identifying software interdependencies using line-of-code behavior and relation models |
JP2022527266A (en) * | 2019-03-25 | 2022-06-01 | オーロラ ラブズ リミテッド | Code line behavior and relational model generation and signature |
US11416385B2 (en) | 2019-03-25 | 2022-08-16 | Aurora Labs Ltd. | Visualization of code execution through line-of-code behavior and relation models |
US11442850B2 (en) | 2019-03-25 | 2022-09-13 | Aurora Labs Ltd. | Identifying software dependencies using controller code models |
US11836428B2 (en) | 2019-03-25 | 2023-12-05 | Aurora Labs Ltd. | Identifying software interdependencies using line-of-code behavior and relation models |
US11467953B2 (en) | 2019-03-25 | 2022-10-11 | Aurora Labs Ltd. | Proving whether software functionality has changed following a software change |
US11481314B2 (en) | 2019-03-25 | 2022-10-25 | Aurora Labs Ltd. | Using line-of-code behavior and relation models to anticipate impact of hardware changes |
US11537509B2 (en) | 2019-03-25 | 2022-12-27 | Aurora Labs Ltd. | Identifying software interdependencies using line-of-code behavior and relation models |
US11651128B2 (en) | 2019-03-25 | 2023-05-16 | Aurora Labs Ltd. | Verifying integrity of controller software updates |
US11694008B2 (en) | 2019-03-25 | 2023-07-04 | Aurora Labs Ltd. | Visualization of code execution through line-of-code behavior and relation models |
US11709981B2 (en) | 2019-03-25 | 2023-07-25 | Aurora Labs Ltd. | Dynamic CFI using line-of-code behavior and relation models |
US11720731B2 (en) | 2019-03-25 | 2023-08-08 | Aurora Labs Ltd. | Verifying software malfunction sources among disparate code sources |
US11741280B2 (en) | 2019-03-25 | 2023-08-29 | Aurora Labs Ltd. | Identifying software dependencies using controller code models |
US11741281B2 (en) | 2019-03-25 | 2023-08-29 | Aurora Labs Ltd. | Using line-of-code behavior and relation models to anticipate impact of hardware changes |
US11074062B1 (en) * | 2019-08-14 | 2021-07-27 | Amazon Technologies, Inc. | Neural networks for software patch applicability |
CN115145633A (en) * | 2022-07-25 | 2022-10-04 | 杭州师范大学 | Code error automatic detection method based on control flow graph |
Also Published As
Publication number | Publication date |
---|---|
US9459861B1 (en) | 2016-10-04 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US9459861B1 (en) | Systems and methods for detecting copied computer code using fingerprints | |
EP3126958B1 (en) | Systems and methods for detecting copied computer code using fingerprints | |
Radovic et al. | Minimum redundancy maximum relevance feature selection approach for temporal gene expression data | |
Lee et al. | Machine learning based file entropy analysis for ransomware detection in backup systems | |
Amer et al. | A multi-perspective malware detection approach through behavioral fusion of api call sequence | |
Zou et al. | Improving tRNAscan‐SE annotation results via ensemble classifiers | |
US20110029476A1 (en) | Indicating relationships among text documents including a patent based on characteristics of the text documents | |
Kamaludin et al. | Clone tag detection in distributed RFID systems | |
Palmer et al. | Improving de novo sequence assembly using machine learning and comparative genomics for overlap correction | |
Hua et al. | Strong approximate Markov blanket and its application on filter-based feature selection | |
Caldonazzo Garbelini et al. | Sequence motif finder using memetic algorithm | |
Hejase et al. | Improving drug sensitivity prediction using different types of data | |
Parkkinen et al. | Searching for functional gene modules with interaction component models | |
AU2016235121B2 (en) | Systems and methods for detecting copied computer code using fingerprints | |
KR102318991B1 (en) | Method and device for detecting malware based on similarity | |
Amira et al. | A survey of malware analysis using community detection algorithms | |
Gater et al. | A summary-based approach for enhancing process model matchmaking | |
US10261784B1 (en) | Detecting copied computer code using cryptographically hashed overlapping shingles | |
Fan et al. | On the Robustness of Split Learning against Adversarial Attacks | |
Zhang et al. | Mac: A probabilistic framework for query answering with machine-crowd collaboration | |
US7542606B2 (en) | Use of Hausdorff distances in the earth mover linear program | |
Valejo et al. | Multilevel refinement based on neighborhood similarity | |
Vitek et al. | Reconsidering complete search algorithms for protein backbone NMR assignment | |
Feitosa Neto et al. | Multiobjective optimization techniques for selecting important metrics in the design of ensemble systems | |
US20240045952A1 (en) | Protection of neural networks against cloning attacks |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: TERBIUM LABS, INC., MARYLAND Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:ROGERS, DANIEL J.;MOORE, MICHAEL;BLAZAKIS, DIONYSUS;REEL/FRAME:038093/0439 Effective date: 20160322 |
|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
AS | Assignment |
Owner name: SILICON VALLEY BANK, CALIFORNIA Free format text: SECURITY INTEREST;ASSIGNOR:TERBIUM LABS, INC.;REEL/FRAME:051014/0112 Effective date: 20191101 |
|
MAFP | Maintenance fee payment |
Free format text: PAYMENT OF MAINTENANCE FEE, 4TH YR, SMALL ENTITY (ORIGINAL EVENT CODE: M2551); ENTITY STATUS OF PATENT OWNER: SMALL ENTITY Year of fee payment: 4 |
|
AS | Assignment |
Owner name: TERBIUM LABS, INC., MARYLAND Free format text: RELEASE BY SECURED PARTY;ASSIGNOR:SILICON VALLEY BANK;REEL/FRAME:056597/0362 Effective date: 20210614 |
|
AS | Assignment |
Owner name: DELOITTE DEVELOPMENT LLC, TENNESSEE Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:TERBIUM LABS, INC.;REEL/FRAME:057206/0856 Effective date: 20210614 |
|
FEPP | Fee payment procedure |
Free format text: ENTITY STATUS SET TO UNDISCOUNTED (ORIGINAL EVENT CODE: BIG.); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
FEPP | Fee payment procedure |
Free format text: 7.5 YR SURCHARGE - LATE PMT W/IN 6 MO, LARGE ENTITY (ORIGINAL EVENT CODE: M1555); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
MAFP | Maintenance fee payment |
Free format text: PAYMENT OF MAINTENANCE FEE, 8TH YEAR, LARGE ENTITY (ORIGINAL EVENT CODE: M1552); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY Year of fee payment: 8 |