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 an execution code providing method and a software development system.

Background Art

[0002] The recent progress of information and communication technology (ICT) has been remarkable. Devices connected to networks such as the Internet are spreading not only to conventional information processing devices such as personal computers and smartphones but also to various things. Such a technological trend is called "IoT (Internet of Things)", and various technologies and services are being proposed and put into practical use. In the future, a world where billions of people on the earth and hundreds of billions or trillions of devices are simultaneously connected is assumed. In order to realize such a networked world, it is necessary to provide a solution that can be connected more simply, more securely, and more freely.

[0003] With the intelligence of devices used in IoT (also referred to as "edge devices"), various types of application programs can be executed on edge devices. On the other hand, it is not easy to enhance the security of edge devices to the same level as that of servers and personal computers due to resource constraints and the like. Therefore, verification of application programs incorporated into edge devices becomes important.

[0004] For example, Japanese Patent Application Laid-Open No. 2014-174577 (Patent Document 1) discloses an improvement of a static analysis tool for verifying the vulnerability of a web application at the source code level.

Prior Art Documents

Patent Documents

[0005] [Patent Document 1] Japanese Patent Publication No. 2014-174577 [Overview of the project] [Problems that the invention aims to solve]

[0006] Application programs used on edge devices and other similar devices are distributed not in the form of source code, but as intermediate representations before executable code is generated. This is often the case. Adopting such an intermediate representation has the advantage of concealing know-how and other information contained in the source code, while also reducing the amount of data.

[0007] As disclosed in Patent Document 1 above, it is common practice to analyze source code to evaluate security holes and vulnerabilities, but it is not easy to evaluate security holes and vulnerabilities in formats other than source code.

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

[0009] A method for providing executable code in accordance with one form of this disclosure includes the steps of: creating source code in accordance with user operations; generating an intermediate representation from the source code; verifying whether the intermediate representation satisfies predetermined rules or conventions; and, if the intermediate representation satisfies the predetermined rules or conventions, executing the executable code generated from the intermediate representation. Includes steps.

[0010] The step of implementing the executable code may include the step of generating executable code from the intermediate representation, provided that the intermediate representation satisfies a predetermined set of rules or conventions.

[0011] The step of enabling the execution of executable code may include a step of allowing the execution of executable code generated from the intermediate representation, provided that the intermediate representation satisfies certain rules or conventions.

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

[0013] The verification step may include issuing a certificate associated with the intermediate representation if the intermediate representation satisfies a prescribed set of rules or conventions, and the step of permitting the execution of executable code generated from the intermediate representation may include determining whether or not to allow execution based on the certificate.

[0014] The verification step may include a step of notifying the user of the content of the failure to meet the prescribed rules or regulations if the intermediate expression does not meet the prescribed rules or regulations.

[0015] A software development system according to another form of this disclosure includes a software development device that assists in the creation of source code and a verification server accessible from the software development device. The software development device includes means for generating an intermediate representation from the source code. The verification server includes means for verifying whether the intermediate representation satisfies predetermined rules or conventions. If the intermediate representation satisfies predetermined rules or conventions, execution of executable code generated from the intermediate representation is achieved. [Effects of the Invention]

[0016] According to this disclosure, we can provide a solution that can ensure the security of application programs. [Brief explanation of the drawing]

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

Embodiments for Carrying Out the Invention

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

[0019] <A. Outline> First, the outline of processing in the software development system 1 according to this embodiment will be described. In this 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 condition that the verification result is appropriate. In the verification of the intermediate representation 20, it is judged to be appropriate when the intermediate representation 20 satisfies a predetermined rule or convention.

[0020] In this specification, "intermediate representation" includes the machine language for a specific virtual machine generated from source code written in any programming language (usually a high-level language) in a compiler infrastructure. However, the "intermediate representation" does not necessarily have to be in binary form and may be expressed in a form similar to a natural language such as assembly language. Furthermore, the "intermediate representation" may adopt any expression form as long as it is generated targeting a specific virtual machine.

[0021] Usually, the "intermediate representation" is generated independently of the platform and architecture on which the executable code 30 runs. A static compiler may be used to generate the intermediate representation 20 from such source code 10. Furthermore, the "intermediate representation" may be compiled into executable code 30 targeted at a specific platform and architecture. The "intermediate representation" and the "executable code" are generated as a set. The "intermediate representation" reduces the amount of data compared to the original source code and can also streamline the described processing itself.

[0022] The generation of the intermediate representation 20 from the source code 10 is basically a one-way conversion, and it is difficult to fully restore the source code 10 from the intermediate representation 20. It is also possible to perform a two-way conversion between the intermediate representation 20 and the executable code 30.

[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 the intermediate representation 20 generated from the source code 10 is used as a generation condition for the executable code 30. FIG. 1(B) shows an example in which the successful verification of the intermediate representation 20 generated from the source code 10 is used as an execution condition for the executable code 30 generated from the intermediate representation 20.

[0024] As shown in Figures 1(A) and (B), the intermediate representation 20 generated from the source code 10 is verified by an arbitrary entity. In the examples shown in Figures 1(A) and (B), the verification server 200 verifies the intermediate representation 20, but the verification is not limited to this, and it may be verified by any entity.

[0025] Referring to Figure 1(A), if the verification result by the verification server 200 is appropriate, the verification server 200 grants authentication to the intermediate representation 20. With authentication of the intermediate representation 20 as a generation condition, the executable code 30 is generated from the intermediate representation 20. In this way, verification of the intermediate representation 20 may be included as a generation condition for the executable code 30. By adopting such a generation condition, the security of the generated executable code 30 can be enhanced.

[0026] Referring to Figure 1(B), if the verification result by the verification server 200 is appropriate, the verification server 200 issues a certificate 40 that includes authentication for the intermediate representation 20. In parallel, executable code 30 is generated from the intermediate representation 20. The execution of the generated executable code 30 may be 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 as an execution condition for the executable code 30. By adopting row conditions, the possibility of executable code 30 being executed in a state where safety is compromised can be reduced.

[0027] As described above, in the series of processes in this embodiment, authentication is granted that allows the generation or execution of the executable code 30 corresponding to the intermediate expression 20 if the intermediate expression 20 satisfies predetermined provisions or rules (if the verification result is appropriate). Conversely, if the intermediate expression 20 does not satisfy predetermined provisions or rules (if the verification result is inappropriate), authentication is not granted, and the generation or execution of the executable code 30 corresponding to the intermediate expression 20 is not possible. In other words, the execution of the executable code 30 generated from the intermediate expression 20 is realized only when the intermediate expression 20 satisfies predetermined provisions or rules.

[0028] As a process to realize the execution of the executable code 30, as shown in Figure 1(A), a process may be adopted in which the executable code 30 is generated from the intermediate representation 20 on the condition that the intermediate representation 20 satisfies predetermined rules or conventions. Alternatively, as a process to realize the execution of the executable code 30, as shown in Figure 1(B), a process may be adopted in which the execution of the executable code 30 generated from the intermediate representation 20 is permitted on the condition that the intermediate representation 20 satisfies predetermined rules or conventions. In this case, whether or not to permit the execution of the executable code 30 generated from the intermediate representation 20 may be determined based on the certificate 40 associated with the intermediate representation 20. Note that the decision on whether or not to allow execution may also be made in the execution environment of the executable code 30 (processor or microcomputer containing a processor, etc.).

[0029] Thus, in this embodiment, by performing verification on the intermediate representation 20 rather than the source code 10, it is possible to more efficiently discover security risks contained in the application program while keeping the know-how 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 depending on the type of programming language used to write the source code 10, thereby achieving efficient verification.

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

[0031] Figures 2 and 3 show an overview of the procedure for generating executable code 30 from source code 10 in a software development system 1 according to this embodiment.

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

[0033] The software development device 100 assists in creating application programs that run on the controller 300 included in the edge device 4. However, the technical scope of the present invention is not limited to creating application programs that run on the edge device 4, but is applicable to creating application programs that run on any computing device.

[0034] The software development device 100 is provided with an Integrated Development Environment (IDE), which allows users to create any application program.

[0035] The controller 300 included in edge device 4 is an example of a computing device and includes a processor. Edge device 4 can be any type of device. While other applications are also possible, typical examples include factory equipment, various household devices, social infrastructure equipment, mobile devices such as vehicles, and any portable device. 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, the user creates source code using the software development device 100 ((1) Source code creation). Then, the created source code is compiled in the software development device 100 to generate an 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 apparatus 100 ((4) Verification of Intermediate Representation). The verification server 200 responds to the software development apparatus 100 with the verification result. If the target intermediate representation 20 passes all verifications, the verification server 200 will transmit an authentication indicating that the verification result was appropriate to the software development apparatus 100.

[0038] When the software development apparatus 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) Execution Code Generation).

[0039] Then, the software development apparatus 100 transfers the generated execution code 30 to the controller 300 of the edge device 4 ((7) Execution Code Transfer). Then, the controller 300 of the edge device 4 executes the transferred execution code 30 as necessary ((8) Execution of 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 Apparatus 100) The software development apparatus 100 is typically realized by a general-purpose computer.

[0043] Figure 4 is a schematic diagram showing an example of the hardware configuration of a software development device 100 according to this embodiment. Referring to Figure 4, the software development device 100 includes, as its 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 composed of, for example, a CPU (Central Processing Unit) and a GPU (Graphics Processing Unit). Multiple processors 102 may be arranged. Alternatively, a processor 102 having multiple cores may be used.

[0045] Main memory 104 consists of volatile storage devices such as DRAM (Dynamic Random Access Memory) and SRAM (Static Random Access Memory). Hard disk 110 This holds various programs and data executed by processor 102. Note that instead of the hard disk 110, an SSD (Solid State Drive) or flash memory can be used. A volatile storage device may be used. Of the programs stored in the hard disk 110, the specified program code is loaded onto the main memory 104, and the processor 102 sequentially executes the computer-readable instructions contained in the program code loaded onto the main memory 104 to realize various functions as described later.

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

[0047] The input unit 106 receives input from a user operating the software development device 100. The input unit 106 may be, for example, a keyboard, a mouse, a touch panel on a display device, or operation buttons located on the casing of the software development device 100.

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

[0049] The communication interface 122 is responsible for data exchange with the verification server 200. The communication interface 122 may include an Ethernet® port, for example, to enable communication over the Internet.

[0050] Furthermore, all or part of the software development device 100 incorporates an ASIC (Application Specific Integrated Circuit) or similar, which has a circuit equivalent to a computer-readable instruction set. This may be implemented using hardwired circuits. Alternatively, it may be implemented using circuits equivalent to computer-readable instructions on an FPGA (field-programmable gate array). Alternatively, it may be implemented by combining the processor 102, main memory, ASIC, FPGA, etc., as appropriate.

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

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

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

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

[0055] The processor 202 consists of, for example, a CPU and a GPU. Multiple processors 202 may be arranged, or a processor 202 with multiple cores may be used.

[0056] The main memory 204 is composed of volatile memory devices such as DRAM and SRAM. The hard disk 210 holds various programs and data executed by the processor 202. Alternatively, a non-volatile memory device such as an SSD or flash memory may be used instead of the hard disk 210. From the programs stored in the hard disk 210, the specified program code is loaded onto the main memory 204, and the processor 202 sequentially executes the computer-readable instructions contained in the program code loaded onto the main memory 204, thereby realizing various functions as described later.

[0057] Typically, the hard disk 210 stores an evaluation engine 212 for performing evaluation processing upon request from an external source, a certificate issuing engine 214 for issuing certificates according to the evaluation results of 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 provisions or rules. The certificate issuing engine 214 issues a certificate 40 associated with the intermediate representation 20 if the intermediate representation 20 satisfies predetermined provisions or rules. Details of the operation and data structure of these elements will be described later.

[0058] The input unit 206 accepts input operations from the user operating the controller 300. The display 208 displays the processing results from the processor 202, etc.

[0059] The communication interface 222 is responsible for data exchange with the software development device 100. The communication interface 222 may include an Ethernet® port, for example, 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 a processor 202, a main memory, an ASIC, an FPGA, and the like.

[0061] Note that the programs 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 conditions for the safety of the application program (intermediate representation 20 and corresponding execution code 30). Examples of such safety conditions typically include the following.

[0065] (1) That there is no memory operation for which 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 disorderly error handling The memory operations for which safety cannot be confirmed (or dangerous memory operations) in (1) above include memory access to system areas or secure areas, and memory operations such as block erasure or block writing to memory areas.

[0066] The undefined behavior described in (2) above includes procedures and functions in the code for which no processing is defined.

[0067] The error handling syntax in (3) above includes a description that specifies how to handle the case when an exception occurs. The disorderly error handling described in (4) above includes excessive error handling when an exception occurs.

[0068] Furthermore, the prescribed rules or regulations include ensuring that the application program (intermediate representation 20 and corresponding executable code 30) does not contain so-called backdoors. A backdoor refers to a function or connection point that allows a third party (usually malicious) to access the application program in a way that is not known to the user of the application program. In the verification of the intermediate representation 20, it is determined whether or not an external access path is included in the intermediate representation 20.

[0069] The verification process described above may be implemented by referring to evaluation rule 216 (Figure 5), which includes prescribed provisions or regulations, or by using machine learning such as AI (Artificial Intelligence) to sequentially update the verification model for implementing the verification process. You can do that.

[0070] The verification process in the software development system 1 according to this embodiment may be executed on the verification server 200 or on the software development device 100. When executed on the verification server 200, it may be implemented in the form of cloud computing. Furthermore, when the verification process is executed on the software development device 100, an evaluation rule 216 certified by an external certification body 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 satisfy 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 the 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 the 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 to generate the 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 performs verification on the requested intermediate representation 20 (step S200).

[0076] That is, in steps S104 and S200, a process for 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 apparatus 100 responds to the verification of the intermediate representation 20 to the software development apparatus 100 (step S204). On the other hand, if the verification result is inappropriate (NO in step S202), the software development apparatus 100 does not give the verification of the intermediate representation 20, and responds to the software development apparatus 100 that the verification result is inappropriate (step S206).

[0078] When the verification of the intermediate representation 20 is responded from the verification server 200 (YES in step S108), the software development apparatus 100 generates an execution code 30 from the target intermediate representation 20 (step S110). Then, the software development apparatus 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 rule or convention, the execution of the execution code 30 generated from the intermediate representation 20 is realized.

[0080] On the other hand, if the verification of the intermediate representation 20 is not responded from the verification server 200 (NO in step S108), the software development apparatus 100 notifies the user that the source code 10 or the intermediate representation 20 does not satisfy a predetermined rule or convention (step S114). In this way, when the intermediate representation 20 does not satisfy a predetermined rule or convention, a process of notifying the user of the content that does not satisfy the predetermined rule 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 verification of the intermediate representation 20.

[0082] Also, a signature common to both the certificate 40 for the intermediate representation 20 generated in the software development system 1 according to the present embodiment and the executable code 30 generated from the intermediate representation 20 (for example, a hash value generated from the authenticated intermediate representation 20) may be embedded, and it may be conditional on the existence of the corresponding certificate 40. In this case, in the environment where the executable code 30 is executed (typically, the firmware of a microcomputer), a process for confirming the match between the signature included in the executable 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 executable code 30 may be performed at any timing, but typically, it may be performed at the time of startup of the controller 300 which is the execution environment (during the startup of the firmware or before the start of application execution immediately after startup). That is, at the time of startup of the controller 300 where the executable code 30 is executed, the legitimacy of the executable code 30 may be evaluated based on the certificate 40 issued in association with the intermediate representation 20 that generated the executable code 30. By confirming that the executable code 30 of the application program is authenticated at the time of startup 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. Modified Example> When requesting the verification server 200 to verify the intermediate representation 20 from the software development device 100, the target intermediate representation 20 may be encrypted. Thereby, it is possible to prevent tampering or the like with the intermediate representation 20 exchanged between the software development device 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 tampering with the certificate 40 issued by the verification server 200.

[0086] In the above description, a configuration example 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 has been described. 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 the 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 certificate 40 together, so that the application distribution server side can directly or indirectly verify the execution code 30 scheduled for distribution. By introducing the mechanism according to the present embodiment in this way, 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, risks regarding the security included in the application program can be more efficiently discovered while keeping the know-how and the like included in the source code 10 confidential. Further, by verifying the intermediate representation 20, it is not necessary to prepare a plurality of verification rule sets or the like 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 devices, 10 Source code, 20 Intermediate representation, 30 Executable code, 40 Certificates, 100 Software Development equipment, 102,202; Processor, 104,204; Main memory, 106,206; Input section, 108,208; Display, 110,210; Hard disk, 114 Software development programs, 120,220 internal buses, 122,222 communication interfaces, 200 verification servers, 212 evaluation engines, 214 certificate issuance engines, 216 evaluation rules, 300 controllers.

Claims

1. An information processing system, A means of obtaining an intermediate representation for a specific architecture, generated from source code in a development environment, A means for verifying whether the aforementioned intermediate expression satisfies the prescribed provisions or rules, The system includes means for outputting the results of the verification performed by the verification means, The means for verifying whether the aforementioned prescribed provisions or regulations are met is: Verification of whether or not memory operations whose safety cannot be confirmed may occur. Verification of whether undefined behavior may occur. Verification of whether or not error handling syntax is missing, and An information processing system that performs at least one of the following: checking whether or not it includes excessive error handling in the event of an exception.

2. The information processing system according to claim 1, further comprising means for permitting the generation of executable code from the intermediate representation if the intermediate representation satisfies the predetermined provisions or rules.

3. The information processing system according to claim 1 or 2, wherein the output means notifies the user of the content that does not satisfy the predetermined provisions or rules when the intermediate expression does not satisfy the predetermined provisions or rules.

4. The information processing system according to any one of claims 1 to 3, further comprising means for issuing a certificate associated with the intermediate expression if the intermediate expression satisfies the predetermined provisions or rules.

5. The system further comprises means for generating the intermediate representation from the source code, The information processing system according to any one of claims 1 to 4, wherein the means for generating the intermediate representation is provided by a computer separate from the computer equipped with the verification means.

6. An information processing method performed by one or more computers, The steps include obtaining an intermediate representation for a specific architecture, generated from the source code in the development environment, and The steps include verifying whether the aforementioned intermediate expression satisfies the prescribed provisions or rules, The system includes a step of outputting the results of the verification step, The step of verifying whether the aforementioned prescribed provisions or regulations are met is: A step to verify whether or not memory operations whose safety cannot be confirmed may occur, A step to verify whether undefined behavior may occur, A step to verify whether or not error handling syntax is missing, An information processing method comprising at least one of the following steps: verifying whether or not it includes excessive error handling in the event of an exception; and

7. An information processing program, for a computer, The steps include obtaining an intermediate representation for a specific architecture, generated from the source code in the development environment, and The steps include verifying whether the aforementioned intermediate expression satisfies the prescribed provisions or rules, The process involves executing the step of outputting the results of the verification step, The step of verifying whether the aforementioned prescribed provisions or regulations are met is: A step to verify whether or not memory operations whose safety cannot be confirmed may occur, A step to verify whether undefined behavior may occur, A step to verify whether or not error handling syntax is missing, An information processing program that includes at least one of the following steps: verifying whether or not it includes excessive error handling in case of an exception; and

Images