KR101780233B1 - Apparatus and method for deteting code cloning of software - Google Patents

Abstract

The present invention includes a processor for executing a program and a memory storing a program for detecting a code clone in software. At this time, the processor extracts a plurality of functions from the source code corresponding to the software, performs normalization and abstraction, compares a plurality of normalized and abstracted functions with a set of weak code clones, determines whether or not the software is cloned, A code clone set includes a plurality of fragile codes that are extracted from a function included in a plurality of other software and normalized and abstracted and stored.

Description

[0001] APPARATUS AND METHOD FOR DETECTION CODE CLONING OF SOFTWARE [0002]

The present invention relates to an apparatus and a method for detecting a code clone of software.

As the number of open source software (OSS) programs has increased in recent years, it has become increasingly difficult for developers to implement some of the functions required for software development and to copy or reuse some or all of the code implemented in well- Cloning is also increasing. Such code cloning has the advantage of shortening development time and cost. Therefore, many developers are using code cloning of open source software known at the time of software development.

However, code cloning can cause open source licensing violations due to code duplication that does not comply with the license policy. In addition, if there is a bug or security vulnerability in the original software, code cloning can also replicate bugs or vulnerabilities. Therefore, code-cloned software may have the same software bug or security vulnerability.

A conventional code cloning detection method is a method of comparing source code included in all or a part of the original source code and a suspected source code of a code clone or by comparing extracted key syntax or token based on parsing, Cloning can be detected. However, this conventional method performs string comparison, so it uses a lot of computing resources, and it may take a long time to detect a code clone.

In this regard, Korean Patent Laid-Open Publication No. 10-2014-0001951 (entitled " Method and System for Performing Intelligent Code Differencing Using Code Clone Detection ") identifies large and complex source code changes, Discloses a technique for tracking changes using a code differencing tool.

SUMMARY OF THE INVENTION The present invention has been made to solve the above-mentioned problems of the prior art, and it is an object of the present invention to provide a code clone detecting apparatus and method capable of detecting a code clone of software quickly and efficiently by reducing a search range for detecting a code clone based on a dictionary data structure to provide.

It should be understood, however, that the technical scope of the present invention is not limited to the above-described technical problems, and other technical problems may exist.

As a technical means for achieving the above technical object, a code clone detecting apparatus of software according to the first aspect of the present invention includes a processor for executing a program and a memory storing a program for detecting a code clone in software. At this time, the processor extracts a plurality of functions from the source code corresponding to software, performs normalization and abstraction, compares a plurality of normalized and abstracted functions with a set of weak code clones, determines whether or not the software is cloned, A code clone set includes a plurality of fragile codes that are extracted from a function included in a plurality of other software and normalized and abstracted and stored.

According to a second aspect of the present invention, there is provided a method of detecting a code clone of software in a code clone detecting apparatus, comprising: extracting a plurality of functions from a source code corresponding to software; Performing normalization and abstraction on a plurality of extracted functions; And comparing the plurality of normalized and abstracted functions with a set of weak code clones to determine whether the code is cloned for the software. At this time, the vulnerable code clone aggregate includes a plurality of fragile codes that are extracted from functions included in a plurality of other software programs and normalized and abstracted and stored.

The present invention performs normalization and abstraction on source code included in software, so that code clones can be detected even when the names and data types of functions and variables included in the source code are modified.

In addition, the present invention first compares a set of a weak code clone and an integer type key for the corresponding software based on a dictionary data structure, compares the hash values included in the reduced search range through a key search, Since the code clone is detected, the time complexity can be reduced. That is, since the present invention can detect a code clone within a constant time, a code clone of a large-capacity open source software can be detected quickly and efficiently.

1 is a block diagram of a code clone detection apparatus for software according to an embodiment of the present invention.
2 is an illustration of source code of software in accordance with an embodiment of the present invention.
FIG. 3 is a diagram illustrating a code clone detection process according to an embodiment of the present invention. Referring to FIG.
4 is an illustration of an abstraction of a function according to an embodiment of the present invention.
5 is a flowchart of a method of detecting a code clone of software of a code clone detecting apparatus according to an embodiment of the present invention.

Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings, which will be readily apparent to those skilled in the art. The present invention may, however, be embodied in many different forms and should not be construed as limited to the embodiments set forth herein. In order to clearly illustrate the present invention, parts not related to the description are omitted, and similar parts are denoted by like reference characters throughout the specification.

Throughout the specification, when a part is referred to as being "connected" to another part, it includes not only "directly connected" but also "electrically connected" with another part in between . Also, when a part is referred to as "including " an element, it does not exclude other elements unless specifically stated otherwise.

Code cloning means copying some or all of the source code of other software. There are four types of code cloning.

The first type of code cloning is to replicate the source code without modification. At this time, the original source code and the source code of the code clone are exactly matched.

The second type of code cloning is to modify the names or types of some variables and functions in the source code. Therefore, the original source code and the code cloned source code are matched with other syntaxes except data type, identifier, comment, and white space.

The third type of code cloning involves modifying the names of some variables or functions in the source code, and correcting the structure. At this time, the correction of the structure may include inserting or deleting a part of the source code, or rearranging some sentences. Therefore, only a portion of the original source code and the source code of the code can be matched.

The fourth type of code cloning is also a semantic clone. At this time, the original source code and the code cloned source code are different from each other in syntax. However, the original source code and the code cloned source code are functionally identical, so the same thing can be done.

Compensating the structure of a part of the source code or performing the third and fourth types of semantically duplicating the source code requires sufficient analysis of the original source code and verification and debugging of the added syntax . Therefore, it takes a lot of time to perform the third type and the fourth type, and a high level of programming skill is required.

In other words, code cloning is usually done to save time and effort in developing source code, so it corresponds to the first type or the second type. Therefore, the code clone detection apparatus 100 of the software according to an embodiment of the present invention targets the first type and the second type of code clone. That is, the code clone detecting apparatus 100 may be configured such that the user performing the code cloning replicates the specific function contained in the source code directly, or changes the name of the function, the type of the variable and the name of the variable included in the specific function, Clones can be detected.

Hereinafter, software developed using a programming language of the C language and C ++ language series may be referred to as a code clone detection apparatus 100 and a code clone detection method of the code clone detection apparatus 100 according to an embodiment of the present invention. Explain. However, the programming language is not limited to this, and may include various programming languages such as JAVA, C #, Python, and BASIC other than the programming languages of the C and C ++ language series.

Next, a code clone detection apparatus 100 of software according to an embodiment of the present invention will be described with reference to Figs.

1 is a block diagram of a code clone detection device 100 of software in accordance with an embodiment of the present invention.

The code clone detection apparatus 100 detects a code clone for open source software from the source code included in the software.

In general, the software may include one or more files. A file may contain functions, variables and constants, and so on.

A function may actually contain instructions, constants, and variables that perform a task. At this time, the function may be a module, a method, a procedure, and the like according to a programming environment in which the software is developed, but is not limited thereto.

For example, functions in C or C ++ languages are separated into a header and a main. At this time, the header includes a data type of a value to be returned, a function name, and a data type of a plurality of parameters input to the function. In addition, the main includes one or more lines in which the specific work done by the function is specified. In the case of including a plurality of lines, the main includes braces ('{', '}') and may include a plurality of lines in curly braces ('{', '}').

Also, in C or C ++ languages, one line can be separated by a semi-clone (';'). That is, regardless of the occurrence of the newline character ('\ n'), the included character can be a single line until a semiclon (';') appears.

The code clone detection apparatus 100 can detect a code clone based on a plurality of functions included in the source code of the software. At this time, the code clone detection apparatus 100 may include a memory 110, a database 120, and a processor 130. The code clone detection device 100 of FIG. 1 is not applicable to one embodiment of the present invention. Therefore, the code clone detecting apparatus 100 can be modified in various ways based on the components shown in FIG.

The memory 110 stores a program for detecting a code clone in software. At this time, the memory 110 collectively refers to a non-volatile storage device that keeps stored information even when no power is supplied, and a volatile storage device that requires power to maintain stored information.

The database 120 may store a set of vulnerable code clones for detecting code clones. At this time, the database 120 may be connected to the code clone detecting apparatus 100 or may be mounted on the code clone detecting apparatus 100, but the present invention is not limited thereto.

The processor 130 may determine whether the software is a code clone by comparing a plurality of functions included in the source code of the software with a function stored in the set of vulnerable code clones stored in the database 120. [ At this time, the set of vulnerable code clones may include the source code extracted from functions included in a plurality of other software collected. The set of vulnerable code clones may also include, but is not limited to, source code extracted from software containing vulnerable code, or source code extracted from predefined open source software to determine violation of the terms of the license .

2 is an illustration of source code of software in accordance with an embodiment of the present invention.

Referring to FIG. 2, the source code of the software may include a first function 200 and a second function 210. At this time, the plurality of functions included in the source code include a header (201, 211) including a data type of each returned value, a function name, and a data type of a plurality of arguments input to the function, And may include defined bodies 202, 212.

For example, the first function 200 includes "func1 (bar)" as the header 201. Then, the first function 200 uses the body 202 to insert the curly brackets ('{', '}') under the header into the four lines "foo = bar;", "foo ++;", "bar = fun2 foo); " And "return bar; ".

Also, the second function 210 includes "func2 (param)" as the header 211. [ Then, the second function 210 determines the two lines "if (param) {while (param) {param -;}}" within the braces ('{' "return 0; ".

FIG. 3 is a diagram illustrating a code clone detection process according to an embodiment of the present invention. Referring to FIG.

The processor 130 retrieves and extracts a plurality of functions from the source code (S300). The processor 130 may perform normalization and abstraction on the extracted functions (S300, S310). At this time, the processor 130 may use a regular expression (regex).

A regular expression is a formal language used to represent a set of strings, based on certain rules. Regular expressions can be used to extract or remove specific characters within a string. Regular expressions can also be used to extract or abstract variable names and variable types within a string. For example, the processor 130 can extract a function name in a function using "(** ** w + [:] * \ w +)".

Specifically, the function exists in a predetermined format according to the programming language. For example, as described above, functions in the C and C ++ languages have a header and a main. In C and C ++ languages, the header of a function can contain zero or more arguments enclosed in parentheses ('(', ')'), the function name and the data type of the value returned by the function. At this time, if the function does not return a value, the data type of the value returned by the function may be omitted or represented as void.

Also, in C and C ++ languages, the body of a function can be positioned after the header. For example, if there is a brace ('{') after the header, the body of the function can be one or more lines up to the end of the brace ('}'). Also, if there is no brace after the header, the body of the function can be one line after the header.

Therefore, the processor 130 can extract a function based on a regular expression for predefined function extraction, corresponding to a programming language that detects a code clone.

2, the processor 130 extracts "func1 (bar)" from the "func1" function, which is the first function 200, into the function header 201 based on a predetermined regular expression, {&Quot; and "} " immediately below the function header 201 can be extracted from the function header 202 by using the function header 201. [ In addition, the processor 130 extracts "func2 (param)" from the function "func2", which is the second function 210, into the header 211 of the function, Quot; and "} " of < / RTI >

The processor 130 may perform normalization and abstraction on the extracted functions. Referring to FIG. 3, the processor 130 is shown performing abstraction after performing normalization on a plurality of functions. However, Fig. 3 is not applicable to one embodiment of the present invention. Therefore, the order of normalization and abstraction can be variously changed depending on the implementation. That is, the processor 130 performs normalization on a plurality of functions and then performs an abstraction, as shown in FIG. In addition, the processor 130 may perform normalization after performing an abstraction of a plurality of functions.

At this time, the normalization may be to extract the header and the body from the function, and to remove the unnecessary portion of the code clone contained in the extracted body. Specifically, as described above, if the header and the main are separated from the function based on a predetermined format, the processor 130 can remove a portion unnecessary for code clone analysis for a plurality of lines included in the main. At this time, the part that is not necessary for the code clone analysis may be a whitespace character, a comment, or the like.

The processor 130 may separate the header and main from the function and remove the white space character or annotation using the regular expression described above. At this time, the white space character may include a space character, a tab character, and a new line character.

The processor 130 may perform an abstraction on the normalized function.

At this time, the abstraction can be performed to generalize a variable name and a variable data type in a function, and to detect a code clone even when a variable name and a variable type are changed. Indeed, correcting the data type of a variable by modifying the name of the variable or the data type of the variable, or adding a qualifier to the data type of the variable, is more efficient than modifying other parts of the source code It is very easy. Therefore, this can happen very often.

In this manner, the processor 130 can determine the two functions as code clones when the names of the variables included in the two functions or the data types of the variables are different, but the source code performing the actual work is the same. To do this, the processor 130 abstracts the variable name and the data type of the variable to easily detect the variable name and the code clone that modifies the data type of the variable. At this time, the processor 130 may perform the function abstraction using the regular expression described above. The abstraction of the function will be described in detail with reference to Fig.

4 is an illustration of an abstraction of a function according to an embodiment of the present invention.

Figure 4 (a) shows the original function before performing the function abstraction. The header of the function contains "arr", a real array of floats, and "len", an integer type (int). Thus, the processor 130 may perform an abstraction that modifies the variable name of the argument included in the header of the function to a predetermined identifier. For example, the processor 130 may abstract the name of the variable included in the argument of the function to a predetermined identifier "FPARAM" corresponding to the variable included in the argument of the function, as shown in FIG. 4B .

After performing an abstraction on the arguments of the function, the processor 130 may perform an abstraction on the data type of the variable contained in the body of the function. First, the processor 130 may delete the qualifier to the data type of the variable. In this case, the qualifier may be at least one of short, long, signed, unsigned, static, extern, volatile, auto, and resister, but is not limited thereto. The processor 130 may change the integer type data types such as int and char, the real data type such as float and double, the logical data type such as bool, and the data type such as void data type to a predetermined identifier corresponding to the data type.

For example, the processor 130 removes the "static" qualifier of the data type of the variable included in the body of the function, as shown in FIG. 4C, and stores the "sum" The data type of the data type "i" variable can be abstracted to "DTYPE" which is a predetermined identifier corresponding to the data type.

Finally, the processor 130 may abstract the name of the variable contained in the body of the function based on a predetermined identifier corresponding to the name in the variable contained in the body. For example, as shown in FIG. 4D, the processor 130 may abstract the name of a variable included in the body of a function to a variable included in the body, with a predetermined identifier "LVAR" corresponding to the name .

Referring to FIG. 4 (a), which is an original function, and FIG. 4 (d), in which an abstract is completed, the two functions differ in the argument name of the function and the data type and the name of the variable in the function. However, both functions accept the real array type and integer type as arguments and perform the same task of calculating the average of the real type array and outputting it to the screen.

After performing normalization and abstraction on a plurality of functions included in the software, the processor 130 can express the normalized and abstracted functions and the weak code clone sets using a dictionary data structure ( S320).

The dictionary data structure may contain one or more values corresponding to keys and keys. At this time, one or more values may be included in the form of an array or a set. Also, the dictionary data structure may be a hashmark dictionary.

Specifically, the processor 130 sets the hash value corresponding to the abstracted function as the value of the abstracted function body length as a key for each of a plurality of functions included in the software , You can add it to a dictionary data structure. At this time, the processor 130 can extract the hash value corresponding to the key based on the string extracted from the body of the function and the predefined hash function.

For example, a hash function can be defined to satisfy the following three conditions.

Condition 1: Minimize the collision of the hash values calculated through the hash function.

Condition 2: To create a minimal dictionary, set the hash function to include a small number of bits in the hash value.

Condition 3: Set the hash function so that the complexity of the time required to generate the hash value is O (n).

The processor 130 can calculate the collision probability P _collision according to the condition 1, as shown in Equation (1). At this time, the collision probability P is the probability P _{cillision uncollision} and mutually exclusive (mutually exclusive) are not conflict.

In this case, the probability that the collision does not occur from 1 to the ith sample when the i- th sample in the sample space S is not collided with the previously calculated hash value is A _i [math Equation 2].

The processor 130 can calculate the computable value and the probability that no collision will occur with respect to the k messages through the N hash functions based on Equation (2) as in Equation (3). At this time, N and k are natural numbers, and N >> k >> 1.

이므로, [수학식 3]은 [수학식 4]와 같이 표현할 수 있다.Also, based on the Taylor series, when x converges to zero,

(3) can be expressed by the following equation (4). &Quot; (4) "

The processor 130 may calculate the probability P _{collision at} which collision will occur, as shown in equation (5), based on [Equation 1] and [Equation 4]. Further, the processor 130 may calculate (Equation 6) based on [Equation 5] and the Taylor series.

For example, referring to Equation (6), if a 128-bit hash function is used, the hash value may collide once every 2 ³⁷ times. That is, the probability of collision can be 2.776e- ¹⁵ %. That is, according to condition 1, the hash function can use a 128-bit hash function to minimize the collision probability.

In addition, the process may calculate a hash value corresponding to the key based on a known hash function. In this case, the hash function may be a known hash function such as MD4 (message digest 4), MD5 (message digest 5), CityHash, MurmurHash and SpookyHash, or may be a user defined hash function developed for detecting a software code clone .

For example, processor 130 may use MD5, which is a 128 bit hash function, with a small time complexity among known hash functions based on conditions 1 to 3. Referring back to FIG. 2, the processor 130 may set the abstracted body length 39, which is the length of the abstracted body, to the first function 200. Based on the abstracted body and MD5 hash function for the first function 200, the processor 130 may calculate the hash value as "8b03 c2a8 ecea 8cc4 9c6d d780 9771 cfd9 ".

In addition, the processor 130 may set the abstracted body length 39 for the second function 210 to a key. The processor 130 may then set the hash value to "019c e125 de43 45d0 87d7 706f 1482 2bf1" based on the body and hash function of the abstracted second function 210.

The processor 130 may store the key and hash value 204 for the first function 200 and the key and hash value 214 for the second function 210 in a dictionary corresponding to the software. Since the first function 200 and the second function 210 are set in the same key, the values stored in the actual dictionary are stored in the key 39 and the set of hash values corresponding to the key {"8b03 c2a8 ecea 8cc4 9c6d d780 9771 cfd9 Quot ;, "019c e125 de43 45d0 87d7 706f 1482 2bf1"}.

Meanwhile, when a dictionary for a plurality of functions extracted corresponding to the software is generated, the processor 130 can detect a code clone included in the software by comparing the set with the vulnerable code clone set (S330).

At this time, the source code included in the vulnerable code clone set may be normalized and abstracted and stored. That is, the processor 130 may extract a plurality of functions from the collected software and perform normalization and abstraction on the extracted functions before detecting the code clone for the software. The processor 130 may then store the normalized and abstracted functions in a set of vulnerable code clones based on a dictionary data structure. At this time, the dictionary data structure may be a hash mark dictionary, as described above.

In addition, the vulnerable code clone set may include a dictionary generated for each of the one or more software, or a dictionary generated for one or more software.

The process then compares the generated dictionary with the keys of the set of vulnerable code clones when a dictionary containing the functions contained in the software is created. If the key of the dictionary and the key of the set of vulnerable code clones are matched, the processor 130 may compare the respective values included in the key.

Referring again to FIG. 2, the processor 130 may retrieve, for a set of weak code clones, a key that matches the key 39 contained in the dictionary corresponding to the software. If there is no key 39 in the set of weak code clones, the processor 130 may determine that the software is not a code clone.

If there is a key 39 in the set of vulnerable code clones, the processor 130 generates a hash value corresponding to the key 39 and a hash value {"8b03 " extracted from the first function 200 and the second function 210 ... ", "019c ..." If there is no hash value extracted from the first function 200 and the second function 210 in the hash value corresponding to the key 39 in the set of vulnerable code clones, the processor 130 determines that the corresponding software is not a code clone Can be determined. If there is a hash value extracted from the first function 200 and the second function 210 in the hash value corresponding to the key 39 in the set of vulnerable code clones, the processor 130 determines that the corresponding software is a code clone can do.

As such, the processor 130 may first compare the key value of the set of weak code clones and the key value corresponding to the function extracted from the software, based on the dictionary data structure. Therefore, the processor 130 may not compare the plurality of source codes included in the vulnerable code clone set and the plurality of source codes included in the software, respectively. That is, the processor 130 can compare only the source code having the same key value, thereby reducing the search space. In addition, since the key value is an integer, the processor 130 can retrieve the key value faster than the string comparison.

Meanwhile, the processor 130 may determine whether or not the software is a code clone, and then add the dictionary extracted from the software to the vulnerable code clone set. Then, the processor 130 can determine whether or not the code is cloned to other software based on a set of vulnerable code clones in which dictionaries extracted from the corresponding software are added in the future.

5, a method of detecting a code clone of software in a code clone detecting apparatus 100 according to an embodiment of the present invention will be described.

5 is a flowchart of a method of detecting a code clone of software of the code clone detecting apparatus 100 according to an embodiment of the present invention.

The code clone detecting apparatus 100 extracts a plurality of functions from the source code corresponding to the software (S500).

Then, the code clone detection apparatus 100 performs normalization and abstraction based on the extracted functions (S510).

The code clone detection apparatus 100 compares a plurality of abstraction functions with a set of weak code clones to determine whether the code is cloned for the software (S520). At this time, the vulnerable code clone aggregate includes a plurality of fragile codes that are extracted from functions included in a plurality of other software programs and normalized and abstracted and stored.

On the other hand, the code clone detection apparatus 100 can perform a normalization and an abstraction on the basis of a plurality of extracted functions, and then generate a dictionary for software based on a plurality of normalized and abstracted functions.

At this time, the code clone detecting apparatus 100 can set the string length of the normalized and abstracted function as a key of the dictionary. In addition, the code clone detecting apparatus 100 may set the normalized and abstracted function as a value of a dictionary.

Then, the code clone detecting apparatus 100 can compare the generated dictionary and the set of vulnerable code clones to determine whether the code is cloned for the software.

At this time, the set of vulnerable code clones and dictionaries generated corresponding to the corresponding software may be generated based on the dictionary data structure.

Therefore, the code clone detection apparatus 100 can compare the keys of the set of vulnerable code clones with the keys of the dictionary generated corresponding to the corresponding software. If the key values are the same, the code clone detecting apparatus 100 can compare the value corresponding to the key of the vulnerable code clone set with the value corresponding to the key of the dictionary of the corresponding software.

Finally, if the respective values are the same, the processor 130 may detect a code clone of the corresponding software.

The apparatus 100 and method for detecting a code clone for software according to an embodiment of the present invention performs normalization and abstraction on source code included in software, so that the names and data types of functions and variables included in the source code You can detect code clones even if you modify them.

In addition, the code clone detection device 100 and method for software first compares a set of vulnerable code clones and an integer type key for the software based on a dictionary data structure, By comparing the hash values and finally detecting the code clone, the time complexity can be shortened to a constant time. That is, the code clone detection apparatus 100 and method for software can detect a code clone within a constant time, and thus can detect a code clone of a large-capacity open source software quickly and efficiently.

One embodiment of the present invention may also be embodied in the form of a recording medium including instructions executable by a computer, such as program modules, being executed by a computer. Computer readable media can be any available media that can be accessed by a computer and includes both volatile and nonvolatile media, removable and non-removable media. In addition, the computer-readable medium may include both computer storage media and communication media. Computer storage media includes both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Communication media typically includes any information delivery media, including computer readable instructions, data structures, program modules, or other data in a modulated data signal such as a carrier wave, or other transport mechanism.

While the methods and systems of the present invention have been described in connection with specific embodiments, some or all of those elements or operations may be implemented using a computer system having a general purpose hardware architecture.

It will be understood by those skilled in the art that the foregoing description of the present invention is for illustrative purposes only and that those of ordinary skill in the art can readily understand that various changes and modifications may be made without departing from the spirit or essential characteristics of the present invention. will be. It is therefore to be understood that the above-described embodiments are illustrative in all aspects and not restrictive. For example, each component described as a single entity may be distributed and implemented, and components described as being distributed may also be implemented in a combined form.

The scope of the present invention is defined by the appended claims rather than the detailed description and all changes or modifications derived from the meaning and scope of the claims and their equivalents are to be construed as being included within the scope of the present invention do.

100: Code clone detection device
110: Memory
120: Database
130: Processor

Claims (14)

A software code clone detection apparatus, comprising:
The program that detects the code clone in the software stores the memory and
And a processor for executing the program,
The processor extracts a plurality of functions from the source code corresponding to the software, performs normalization and abstraction, sets a key based on the string length of the normalized and abstracted function, and sets a value corresponding to the normalized and abstracted function To create a dictionary,
Comparing the generated dictionary with a vulnerable code clone set to determine whether a code is cloned for the software,
The vulnerable code clone set
A plurality of vulnerable codes extracted from a function included in a plurality of other software programs and normalized and abstracted and stored based on a dictionary data structure. delete delete The method according to claim 1,
The processor compares the key contained in the dictionary and the key of the vulnerable code clone set,
When a key included in the dictionary and a key of the vulnerable code clone set match, compares the value corresponding to the key included in the dictionary and the vulnerable code corresponding to the key of the vulnerable code clone set, Code clone detection means for determining whether or not a code clone is detected. The method according to claim 1,
Wherein the processor computes a value corresponding to the normalized and abstracted function based on an MD5 (message digest 5) algorithm. The method according to claim 1,
Wherein the processor adds the normalized and abstracted functions to the vulnerable code clone set. The method according to claim 1,
Wherein the processor removes whitespace characters included in the extracted functions and converts the characters included in the function in which the white space characters are removed to lower case,
Wherein the white space character comprises a space, a tab character, and a new line character. The method according to claim 1,
Wherein the processor converts a data type of a variable included in the plurality of extracted functions, a name of a variable, and a function factor into a predetermined identifier. The method according to claim 1,
Wherein the processor defines a regular expression based on a programming language corresponding to the software,
Extracts the function based on the regular expression defined above and performs normalization and abstraction on the extracted function. A method of detecting a code clone of software in a code clone detection apparatus,
Extracting a plurality of functions from a source code corresponding to the software;
Performing normalization and abstraction on the extracted functions;
Setting a key based on the string length of the normalized and abstracted function, and setting a value corresponding to the normalized and abstracted function to generate a dictionary; And
Comparing the generated dictionary with a vulnerable code clone set to determine whether the software is a code clone,
The vulnerable code clone set
A method of detecting a code clone, comprising: a plurality of vulnerable codes extracted from a function included in a plurality of other software programs and normalized and abstracted based on a dictionary data structure; delete delete 11. The method of claim 10,
The step of determining whether or not the software is a clone of code,
Comparing the key contained in the dictionary and the key of the vulnerable code clone set;
Performing a comparison between a value corresponding to a key included in the dictionary and a vulnerable code corresponding to a key of the vulnerable code clone set when the key included in the dictionary matches the key of the vulnerable code clone set, Determining whether a code is cloned for the software. A computer-readable recording medium having recorded thereon a program for performing the method according to any one of claims 10 and 13 on a computer.

Images