Information processing method, information processing system, and information processing program

Abstract

To provide a solution that can ensure safety of an application program.SOLUTION: An execution code provision method includes the steps of: creating a source code according to a user operation; generating intermediate representation from the source code; verifying whether the intermediate representation meets a predetermined provision or rule; and realizing, when the intermediate representation meets the predetermined provision or rule, execution of an execution code generated from the intermediate representation.SELECTED DRAWING: Figure 1

Description

[Technical field]

[0001] The present disclosure relates to a method for providing executable code and a software development system. [Background technology]

[0002] Recent advances in Information and Communication Technology (ICT) have been remarkable, and devices connected to networks such as the Internet are no longer limited to conventional information processing devices such as personal computers and smartphones, but are now expanding to include a wide variety of things. This technological trend is known as the "Internet of Things (IoT)," and various technologies and services are being proposed and put into practical use. In the future, it is expected that billions of people and tens of billions or even trillions of devices on Earth will be connected simultaneously. To realize such a networked world, it is necessary to provide solutions that allow connections to be made simpler, safer, and more freely.

[0003] As devices used in IoT (also called "edge devices") become more intelligent, various types of application programs will be able to run on edge devices. However, due to resource constraints and other factors, it is not easy to improve the security of edge devices to the same level as that of servers and personal computers. For this reason, it is becoming increasingly important to verify the application programs that are built into edge devices.

[0004] For example, Japanese Patent Application Laid-Open Publication No. 2014-174577 (Patent Document 1) discloses an improvement to a static analysis tool that verifies vulnerabilities in web applications at the source code level. [Prior art documents] [Patent documents]

[0005] [Patent Document 1] JP 2014-174577 A Summary of the Invention [Problem to be solved by the invention]

[0006] Application programs used in edge devices are distributed not in the form of source code, but as an intermediate representation before the execution code is generated. The use of such intermediate representations has the advantage of keeping the know-how contained in the source code secret and reducing the amount of data.

[0007] As disclosed in the above-mentioned Patent Document 1, it is common to analyze source code to evaluate security holes, vulnerabilities, etc., but it is not easy to evaluate security holes, vulnerabilities, etc. in a format other than source code.

[0008] A typical objective of the present disclosure is to provide a solution that is suitable for edge devices and the like and can ensure the security of application programs. [Means for solving the problem]

[0009] A method for providing executable code according to an embodiment of the present disclosure includes the steps of: creating source code in accordance with a user operation; generating an intermediate representation from the source code; verifying whether the intermediate representation satisfies a predetermined rule or regulation; and, if the intermediate representation satisfies the predetermined rule or regulation, executing the executable code generated from the intermediate representation. The method includes the steps of:

[0010] The step of realizing execution of the executable code may include the step of generating the executable code from the intermediate representation, provided that the intermediate representation satisfies a predetermined rule or convention.

[0011] The step of enabling execution of the executable code may include a step of permitting execution of the executable code generated from the intermediate representation on condition that the intermediate representation satisfies a predetermined rule or convention.

[0012] The method for providing executable code may further include a step of evaluating, at the time of startup of the controller in which the executable code is executed, the legitimacy of the executable code based on a certificate issued in association with the intermediate representation that generated the executable code.

[0013] The verifying step may include a step of issuing a certificate associated with the intermediate representation if the intermediate representation meets certain regulations or rules, and the step of permitting execution of the executable code generated from the intermediate representation may include a step of determining whether or not execution is permitted based on the certificate.

[0014] The step of validating may include a step of notifying a user of the content that does not satisfy the predetermined rules or regulations if the intermediate representation does not satisfy the predetermined rules or regulations.

[0015] A software development system according to another aspect of the present disclosure includes a software development device that supports the creation of source code, and a verification server accessible from the software development device. The software development device includes a means for generating an intermediate representation from the source code. The verification server includes a means for verifying whether the intermediate representation satisfies a predetermined rule or regulation. If the intermediate representation satisfies the predetermined rule or regulation, execution code generated from the intermediate representation is realized. Effect of the Invention

[0016] According to the present disclosure, a solution that can ensure the safety of application programs can be provided. [Brief description of the drawings]

[0017] [Figure 1]This is a diagram for explaining the outline of processing in a software development system according to the present embodiment. [Diagram 2] This is a diagram showing the outline of a procedure for generating executable code from source code in a software development system according to the present embodiment. [Diagram 3] This is a diagram showing the outline of a procedure for generating executable code from source code in a software development system according to the present embodiment. [Figure 4] This is a schematic diagram showing an example of the hardware configuration of a software development apparatus according to the present embodiment. [Diagram 5] This is a schematic diagram showing an example of the hardware configuration of a verification server according to the present embodiment. [Figure 6] This is a flowchart showing an example of a processing procedure in a software development system according to the present embodiment.

Embodiment for Carrying Out the Invention

[0018] Embodiments according to the present disclosure will be described in detail with reference to the drawings. Note that the same or corresponding parts in the drawings are denoted by the same reference numerals and their descriptions will not be repeated.

[0019] <A. Outline> First, the outline of processing in a software development system 1 according to the present embodiment will be described. In the present embodiment, the intermediate representation 20 itself generated from the source code 10 is verified, and generation of the corresponding executable code 30 or execution of the generated executable code 30 is permitted on the condition that the verification result is appropriate. In the verification of the intermediate representation 20, it is determined to be appropriate when the intermediate representation 20 satisfies a predetermined rule or convention.

[0020] In this specification, the term "intermediate representation" includes machine language for a specific virtual machine that is generated on a compiler platform from source code written in an arbitrary programming language (usually a high-level language) with the specific virtual machine as the target. However, the "intermediate representation" does not necessarily have to be in binary format, and may be expressed in a format similar to a natural language such as an assembler language. Furthermore, the "intermediate representation" may adopt any representation format as long as it is generated with the specific virtual machine as the target.

[0021] Typically, the "intermediate representation" is generated independent of the platform and architecture on which the executable code 30 is executed. A static compiler may be used to generate the intermediate representation 20 from the source code 10. Furthermore, the "intermediate representation" may be compiled as the executable code 30 targeted for a specific platform and architecture. The "intermediate representation" and the "executable code" are generated as a set. The "intermediate representation" has a reduced amount of data compared to the original source code, and the process described in the "intermediate representation" can be made more efficient.

[0022] Generating the intermediate representation 20 from the source code 10 is basically a one-way conversion, and it is difficult to completely restore the source code 10 from the intermediate representation 20. Conversion between the intermediate representation 20 and the execution code 30 is also possible in both directions.

[0023] Fig. 1 is a diagram for explaining an overview of processing in a software development system 1 according to this embodiment. Fig. 1(A) shows an example in which the successful verification of an intermediate representation 20 generated from source code 10 is set as a generation condition for execution code 30. Fig. 1(B) shows an example in which the successful verification of an intermediate representation 20 generated from source code 10 is set as an execution condition for execution code 30 generated from intermediate representation 20.

[0024] 1(A) and (B), an intermediate representation 20 generated from a source code 10 is verified by an arbitrary subject. In the example shown in FIG. 1(A) and (B), an example is shown in which a verification server 200 verifies the intermediate representation 20, but the present invention is not limited to this, and verification may be performed by an arbitrary subject.

[0025] 1(A), if the verification result by the verification server 200 is appropriate, the verification server 200 certifies the intermediate representation 20. With the authentication of the intermediate representation 20 as a generation condition, an execution code 30 is generated from the intermediate representation 20. In this manner, the verification of the intermediate representation 20 may be included in the generation conditions of the execution code 30. By employing such a generation condition, the security of the generated execution code 30 can be improved.

[0026] 1B, if the result of the verification by the validation server 200 is appropriate, the validation server 200 issues a certificate 40 including authentication for the intermediate representation 20. In parallel, the execution code 30 is generated from the intermediate representation 20. The execution of the generated execution code 30 may be made conditional on the existence of the corresponding certificate 40. In this way, the existence of the certificate 40 for the intermediate representation 20 may be included in the execution conditions for the execution code 30. In such an execution By employing the line condition, it is possible to reduce the possibility that the executable code 30 will be executed in an unsafe state.

[0027] As described above, in the series of processes in this embodiment, if the intermediate representation 20 satisfies the predetermined rules or regulations (if the verification result is appropriate), authentication is given to permit the generation or execution of the executable code 30 corresponding to the intermediate representation 20. Conversely, if the intermediate representation 20 does not satisfy the predetermined rules or regulations (if the verification result is inappropriate), authentication is not given and the executable code 30 corresponding to the intermediate representation 20 cannot be generated or executed. In other words, if the intermediate representation 20 satisfies the predetermined rules or regulations, execution of the executable code 30 generated from the intermediate representation 20 is realized.

[0028] The process for executing the executable code 30 may be a process for generating the executable code 30 from the intermediate representation 20 on condition that the intermediate representation 20 satisfies a predetermined rule or regulation, as shown in Fig. 1(A). Alternatively, the process for executing the executable code 30 may be a process for permitting execution of the executable code 30 generated from the intermediate representation 20 on condition that the intermediate representation 20 satisfies a predetermined rule or regulation, as shown in Fig. 1(B). In this case, whether or not to permit execution of the executable code 30 generated from the intermediate representation 20 may be determined based on a certificate 40 associated with the intermediate representation 20. Note that the permission of execution may also be determined by the execution environment of the executable code 30 (such as a processor or a microcomputer including a processor).

[0029] In this manner, in this embodiment, by performing verification on the intermediate representation 20 instead of the source code 10, it is possible to more efficiently discover safety risks contained in an application program while keeping know-how, etc., contained in the source code 10 confidential. Furthermore, by performing verification on the intermediate representation 20, it is not necessary to prepare multiple verification rule sets according to the types of programming languages ​​used to write the source code 10, and efficient verification can be realized.

[0030] Next, an example of a procedure for generating execution code 30 using software development system 1 according to the present embodiment will be described.

[0031] 2 and 3 are diagrams showing an outline of a procedure for generating execution code 30 from source code 10 in software development system 1 according to the present embodiment.

[0032] 2, software development system 1 includes one or more software development devices 100, and a verification server 200 accessible from software development device 100 via Internet 2 or the like.

[0033] The software development apparatus 100 assists in the creation of an application program to be executed by a controller 300 included in an edge device 4. However, the technical scope of the present invention is not limited to the creation of an application program to be executed by an edge device 4, and is applicable to the creation of an application program to be executed by any computing device.

[0034] The software development device 100 is provided with an integrated development environment (IDE), and a user can create any application program on the integrated development environment.

[0035] The controller 300 included in the edge device 4 is an example of a computing device and includes a processor. The edge device 4 may be any device. Although the controller 300 may be a computer, typically, it is assumed that the controller 300 is a factory facility, various household devices, social infrastructure facilities, moving objects such as vehicles, any portable device, etc. As will be described later, the controller 300 has a processor and is capable of executing application programs from the software development device 100.

[0036] First, a user creates source code using software development device 100 ((1) Source Code Creation). Then, the created source code is compiled in software development device 100 to generate intermediate representation 20 ((2) Intermediate Representation Generation).

[0037] Before the execution code 30 is generated from the intermediate representation 20, the intermediate representation 20 is verified. In the example shown in FIG. 2, the generated intermediate representation 20 is transmitted to the verification server 200 ((3) Intermediate Representation Verification Request). Then, the verification server 200 verifies the intermediate representation 20 from the software development device 100 ((4) Verification of Intermediate Representation). The verification server 200 responds with the verification result to the software development device 100. If the target intermediate representation 20 passes all verifications, the verification server 200 will send an authentication indicating that the verification result was appropriate to the software development device 100.

[0038] When the software development device 100 receives an authentication indicating that the verification result was appropriate from the verification server 200 ((5) Receiving Verification Result (Authentication)), it generates the execution code 30 from the intermediate representation 20 ((6) Generating Execution Code).

[0039] Then, the software development device 100 transfers the generated execution code 30 to the controller 300 of the edge device 4 ((7) Transferring Execution Code). And the controller 300 of the edge device 4 executes the transferred execution code 30 as needed ((8) Executing Execution Code).

[0040] Through a series of processes as shown in FIGS. 2 and 3, a secure application program can be executed in the controller 300 of the edge device 4.

[0041] <B. Hardware Configuration Example> Next, a hardware configuration example of the main devices constituting the software development system 1 according to the present embodiment will be described.

[0042] (b1: Software Development Device 100) The software development device 100 is typically realized by a general-purpose computer.

[0043] Fig. 4 is a schematic diagram showing an example of a hardware configuration of software development device 100 according to the present embodiment. With reference to Fig. 4, software development device 100 includes, as main components, a processor 102, a main memory 104, an input unit 106, a display 108, a hard disk 110, and a communication interface 122. These components are connected via an internal bus 120.

[0044] The processor 102 is, for example, a central processing unit (CPU) or a graphics processing unit (GPU). A plurality of processors 102 may be provided. , a processor 102 having multiple cores may be employed.

[0045] The main memory 104 is configured with a volatile storage device such as a dynamic random access memory (DRAM) or a static random access memory (SRAM). The hard disk 110 may be replaced with a non-volatile memory such as a solid state drive (SSD) or a flash memory. A volatile storage device may be used. Of the programs stored in the hard disk 110, designated program codes are loaded onto the main memory 104, and the processor 102 sequentially executes computer-readable instructions included in the program codes loaded onto the main memory 104 to realize various functions as described below.

[0046] Typically, the hard disk 110 stores source code 10 created by the user, a software development program 114 for realizing an integrated development environment, and execution code 30 generated from the source code 10. The software development program 114 generates the execution code 30 from the source code 10 created by the user via an intermediate representation 20, and includes a module that provides a development environment for application programs. However, on the condition that the results of verifying the intermediate representation 20 are appropriate, the generation or execution of the corresponding execution code 30 is permitted.

[0047] The input unit 106 accepts input operations from a user who operates the software development device 100. The input unit 106 may be, for example, a keyboard, a mouse, a touch panel arranged on a display device, or operation buttons arranged on the housing of the software development device 100.

[0048] The display 108 displays the results of processing by the processor 102. The display 108 may be, for example, an LCD (Liquid Crystal Display) or an organic EL (Electro-Luminescence) display.

[0049] The communication interface 122 is responsible for exchanging data with the validation server 200. The communication interface 122 may include, for example, an Ethernet port to allow communication over the Internet.

[0050] All or part of the software development device 100 may be implemented using a software program such as an ASIC (Application Specific Integrated Circuit) incorporating a circuit that corresponds to a computer-readable instruction. This may be implemented using hardwired circuitry, or alternatively, using circuitry corresponding to computer-readable instructions on a field-programmable gate array (FPGA). Moreover, it may be realized by appropriately combining the processor 102, a main memory, an ASIC, an FPGA, and the like.

[0051] The software development device 100 may further include a component for reading the stored software development program 114 including computer-readable instructions from a non-transitory medium that stores the program. The medium may be, for example, an optical medium such as a Digital Versatile Disc (DVD), a semiconductor medium such as a USB memory, or the like.

[0052] The software development program 114 may not only be installed in the software development device 100 via a medium, but may also be provided from a distribution server on a network.

[0053] (b2: Verification server 200) The validation server 200 is also typically implemented by a general-purpose computer.

[0054] 5 is a schematic diagram showing an example of a hardware configuration of the validation server 200 according to the present embodiment. Referring to FIG. 5, the validation server 200 includes, as main components, one or more processors 202, a main memory 204, an input unit 206, a display 208, and , a hard disk 210, and a communication interface 222. These components are connected via an internal bus 220.

[0055] The processor 202 is configured, for example, by a CPU, a GPU, etc. A plurality of processors 202 may be arranged, or a processor 202 having a plurality of cores may be employed.

[0056] The main memory 204 is composed of a volatile storage device such as a DRAM or an SRAM. The hard disk 210 holds various programs and various data executed by the processor 202. Note that a non-volatile storage device such as an SSD or a flash memory may be used instead of the hard disk 210. Of the programs stored in the hard disk 210, designated program code is expanded on the main memory 204, and the processor 202 sequentially executes computer-readable instructions included in the program code expanded on the main memory 204 to realize various functions as described below.

[0057] Typically, the hard disk 210 stores an evaluation engine 212 for executing evaluation processing upon receiving an external request, a certificate issuance engine 214 for issuing a certificate according to the evaluation result by the evaluation engine 212, and evaluation rules 216 used in the evaluation processing by the evaluation engine 212. The evaluation engine 212 verifies whether the intermediate representation 20 satisfies predetermined regulations or rules. If the intermediate representation 20 satisfies the predetermined regulations or rules, the certificate issuance engine 214 issues a certificate 40 associated with the intermediate representation 20. Details of the operation and data structures of these elements will be described later.

[0058] The input unit 206 accepts input operations by a user who operates the controller 300. The display 208 displays the results of processing by the processor 202 and the like.

[0059] The communication interface 222 is responsible for exchanging data with the software development device 100. The communication interface 222 may include, for example, an Ethernet port to enable communication over the Internet.

[0060] Note that all or part of the verification server 200 may be implemented using a hardwired circuit such as an ASIC in which a circuit corresponding to computer-readable instructions is incorporated. Alternatively, it may be implemented using a circuit corresponding to computer-readable instructions on an FPGA. Further, it may be implemented by appropriately combining the processor 202, the main memory, the ASIC, the FPGA, and the like.

[0061] Note that the program necessary for execution may not only be installed in the verification server 200 via a medium, but may also be provided from a distribution server on a network.

[0062] <C. Verification Process> Next, the verification process in the software development system 1 according to the present embodiment will be described.

[0063] As described above, the verification of the intermediate representation 20 in the present embodiment includes a process of determining whether the intermediate representation 20 satisfies a predetermined rule or convention.

[0064] The predetermined rules or conventions include the conditions for the application program (intermediate representation 20 and corresponding execution code 30) to be safe. Such conditions for being safe typically include the following.

[0065] (1) That there is no memory operation whose safety cannot be confirmed (or dangerous memory operation) (or that such a memory operation is not compilable) (2) That there is no undefined behavior in the code (3) That there is no lack of error handling syntax (that the error handling syntax is appropriately included) (4) That there is no unordered error handling The memory operation whose safety cannot be confirmed (or dangerous memory operation) in the above (1) includes memory access to the system area or secure area, and memory operations such as block erasure and block writing to the memory area.

[0066] The undefined behavior in (2) above includes procedures and functions whose processing is not defined in the code.

[0067] The error handling syntax in (3) above includes a description that specifies the processing to be performed when an exception occurs. The above (4) uncontrolled error handling includes excessive error handling when an exception occurs.

[0068] Further, the predetermined rules or regulations include that the application program (the intermediate representation 20 and the corresponding executable code 30) does not have a so-called backdoor. A backdoor refers to a function or connection port that allows a (usually malicious) third party to access the application program in a manner not recognized by the user of the application program. In verifying the intermediate representation 20, it is determined whether an access path from outside is included in the intermediate representation 20.

[0069] The above-mentioned verification process may be realized by referring to the evaluation rules 216 (FIG. 5) including predetermined regulations or rules, or may be realized by using machine learning such as so-called AI (Artificial Intelligence) to successively update a verification model for realizing the verification process. It can also be.

[0070] The verification process in the software development system 1 according to the present embodiment may be executed by the verification server 200, or may be executed by the software development device 100. When executed by the verification server 200, it may be implemented in the form of cloud computing. Furthermore, when the verification process is executed by the software development device 100, evaluation rules 216 certified by an external certification organization may be used.

[0071] Regarding the verification process in the software development system 1 according to this embodiment, details of the content determined not to meet a predetermined regulation or convention may be notified to a user or the like.

[0072] <D. Processing procedure> Next, the processing procedure in the software development system 1 according to this embodiment will be described.

[0073] FIG. 6 is a flowchart showing an example of the processing procedure in the software development system 1 according to this embodiment. Regarding the processing executed by the software development apparatus 100 shown in FIG. 6, typically, it may be realized by the processor 102 of the software development apparatus 100 executing a software development program 114. Similarly, regarding the processing executed by the verification server 200, typically, it may be realized by the processor 202 of the verification server 200 executing a necessary program.

[0074] Referring to FIG. 6, the software development apparatus 100 creates a source code 10 according to a user operation (step S100). After creating the source code 10, the software development apparatus 100 compiles the source code 10 according to a user operation and generates an intermediate representation 20 from the source code 10 (step S102).

[0075] The software development apparatus 100 requests the verification server 200 to verify the generated intermediate representation 20 (step S104) and waits for a response from the verification server 200 (step S106). The verification server 200 responds to the verification request from the software development apparatus 100 and verifies the requested intermediate representation 20 (step S200).

[0076] That is, in steps S104 and S200, a process of verifying whether the intermediate representation 20 satisfies a predetermined regulation or convention is executed.

[0077] If the verification result is appropriate (YES in step S202), the software development device 100 responds to the software development device 100 with the authentication for the intermediate representation 20 (step S204). On the other hand, if the verification result is inappropriate (NO in step S202), the software development device 100 does not give the authentication for the intermediate representation 20 and responds to the software development device 100 that the verification result is inappropriate (step S206).

[0078] When the software development device 100 receives the authentication for the intermediate representation 20 from the verification server 200 (YES in step S108), the software development device 100 generates the execution code 30 from the target intermediate representation 20 (step S110). Then, the software development device 100 transfers the generated execution code 30 to the target controller 300 (step S112). Then, the process ends.

[0079] In this way, when the intermediate representation 20 satisfies a predetermined regulation or convention, the execution of the execution code 30 generated from the intermediate representation 20 is realized.

[0080] On the other hand, if the software development device 100 does not receive the authentication for the intermediate representation 20 from the verification server 200 (NO in step S108), the software development device 100 notifies the user that the source code 10 or the intermediate representation 20 does not satisfy a predetermined regulation or convention (step S114). In this way, when the intermediate representation 20 does not satisfy a predetermined regulation or convention, a process of notifying the user of the content that does not satisfy the predetermined regulation or convention may be adopted. Then, the process ends.

[0081] <E. Execution Environment> The execution code 30 generated in the software development system 1 according to the present embodiment is preferably stored in a secure area of a processor or a microcomputer constituting the distribution destination controller 300. That is, it is preferable to take some measures in the execution environment so that no tampering is performed on the execution code 30 generated on the condition of the authentication for the intermediate representation 20.

[0082] Also, a common signature (for example, a hash value generated from the authenticated intermediate representation 20) may be embedded in both the certificate 40 for the intermediate representation 20 generated in the software development system 1 according to this embodiment and the execution code 30 generated from the intermediate representation 20, and it may be conditional on the existence of the corresponding certificate 40. In this case, in the environment where the execution code 30 is executed (typically, the firmware of a microcomputer), a process of confirming the match between the signature included in the execution code 30 and the signature included in the corresponding certificate 40 may be implemented.

[0083] Also, in the execution environment, the evaluation (judgment of legitimacy) of whether to execute the execution code 30 may be performed at any timing, but typically, it may be performed at the time of activation of the controller 300 which is the execution environment (during the activation of the firmware or before the start of application execution immediately after activation). That is, at the time of activation of the controller 300 where the execution code 30 is executed, the legitimacy of the execution code 30 may be evaluated based on the certificate 40 issued in association with the intermediate representation 20 that generated the execution code 30. By confirming that the execution code 30 of the application program is authenticated at the time of activation of the controller 300, it is possible to avoid a situation where undesirable processing is executed in the controller 300 or the like.

[0084] <F. Modification Example> When requesting the verification server 200 to verify the intermediate representation 20 from the software development apparatus 100, the target intermediate representation 20 may be encrypted. Thereby, it is possible to prevent forgery or the like of the intermediate representation 20 exchanged between the software development apparatus 100 and the verification server 200.

[0085] The certificate 40 issued by the verification server 200 may be provided with a signature from a certification authority or the like. Thereby, it is possible to prevent illegal acts such as forgery of the certificate 40 issued by the verification server 200.

[0086] In the above description, a configuration example has been described in which the software development apparatus 100 executes the generation process of the source code 10, the generation process of the intermediate representation 20, and the generation process of the execution code 30. These processes may be executed distributively on a plurality of computing devices.

[0087] The framework of verifying the intermediate representation 20 according to the present embodiment and issuing a certificate 40 indicating the verification result is applicable to a mechanism for selling or distributing an application. For example, when an application developer uploads an application program (execution code 30) to an application distribution server, it is required to upload the corresponding intermediate representation 20 and / or the certificate 40 together, so that the application distribution server side can directly or indirectly verify the execution code 30 scheduled for distribution. In this way, by introducing the mechanism according to the present embodiment, it is possible to avoid a situation where an application program with a backdoor or the like is distributed.

[0088] <G. Advantages> In the present embodiment, by verifying the intermediate representation 20 instead of the source code 10, it is possible to more efficiently discover risks regarding the security included in the application program in a state where know-how and the like included in the source code 10 are anonymized. Further, by verifying the intermediate representation 20, it is not necessary to prepare a plurality of verification rule sets according to the type of programming language used in the description of the source code 10, and efficient verification can be realized.

[0089] The embodiments disclosed this time should be considered as illustrative in all respects and not restrictive. The scope of the present invention is shown not by the above description but by the claims, and it is intended that all modifications within the meaning and scope equivalent to the claims are included.

Description of Reference Numerals

[0090] 1 Software development system, 2 Internet, 4 Edge device, 10 Source code, 20 Intermediate representation, 30 Executable code, 40 Certificate, 100 Software Development device, 102, 202 processor, 104, 204 main memory, 106, 206 input section, 108, 208 display, 110, 210 hard disk, 114 software development program, 120,220 internal bus, 122,222 communication interface, 200 validation server, 212 evaluation engine, 214 certificate issuance engine, 216 evaluation rules, 300 controller.

Claims

1. 1. An information processing method executed by one or more computers, comprising: obtaining an intermediate representation generated from the source code; verifying whether the intermediate representation satisfies predetermined rules or conventions; and responding with a result of the verifying step; The step of verifying whether or not the predetermined rules or regulations are satisfied includes: verifying whether or not a memory operation that cannot be confirmed as safe can occur; verifying whether undefined behavior may occur; verifying whether error handling syntax is missing; verifying whether or not unregulated error handling is involved; and verifying whether a backdoor exists.

2. 2. The information processing method according to claim 1, further comprising the step of permitting generation of executable code from said intermediate representation if said intermediate representation satisfies said predetermined rules or regulations.

3. 3. The information processing method according to claim 1, further comprising the step of, if the intermediate representation does not satisfy the predetermined rules or regulations, notifying a user of the content that does not satisfy the predetermined rules or regulations.

4. 4. The information processing method according to claim 1, further comprising the step of issuing a certificate associated with said intermediate representation if said intermediate representation satisfies said predetermined rules or regulations.

5. generating the intermediate representation from the source code; 5. The information processing method according to claim 1, wherein the step of generating the intermediate representation is executed by a computer different from a computer that executes the step of verifying.

6. An information processing system, a means for obtaining an intermediate representation generated from the source code; means for verifying whether the intermediate representation satisfies predetermined rules or conventions; means for responding with a result of the verifying step; The means for verifying whether the predetermined regulations or rules are met includes: Verify whether unsafe memory operations can occur, Verifying whether undefined behavior can occur, Verifying whether error handling syntax is missing, Verify whether it contains unregulated error handling, and and verifying whether a backdoor exists.

7. An information processing program, which is installed on a computer, obtaining an intermediate representation generated from the source code; verifying whether the intermediate representation satisfies predetermined rules or conventions; and a step of responding with a result of the verifying step; The step of verifying whether or not the predetermined rules or regulations are satisfied includes: verifying whether or not a memory operation that cannot be confirmed as safe can occur; verifying whether undefined behavior may occur; verifying whether error handling syntax is missing; verifying whether or not unregulated error handling is involved; and verifying whether a backdoor exists.

Images