Security assurance system, security assurance method, and program
The safety assurance system employs Proof-Carrying Code to ensure confidential information is securely stored by hashing and verifying the program's compliance with security requirements, addressing the challenge of secure data storage in programs.
Patent Information
- Application Number
- PCT/JP2023/018666
- Authority / Receiving Office
- WO · WO
- Patent Type
- Applications
- Current Assignee / Owner
- Filing Date
- 2023-05-18
- Publication Date
- 2024-11-21
AI Technical Summary
Existing systems fail to guarantee the secure storage of confidential information in programs, particularly in ensuring that sensitive data like passwords are hashed and stored correctly, especially in the context of preventing Rainbow Table Attacks and unauthorized data transmission.
A safety assurance system utilizing Proof-Carrying Code (PCC) technology, which includes a verification logical formula generator, proof generator, and proof verifier, ensures that confidential information is hashed and stored securely by analyzing the program's syntax and generating a verification logical formula to prove compliance with security requirements.
This approach guarantees the secure storage of confidential information by verifying that the program correctly hashes sensitive data before writing it outside, providing users with assurance of the program's security and reducing the risk of data breaches.
Smart Images

Figure JP2023018666_21112024_PF_FP_ABST
Abstract
Description
Safety assurance system, safety assurance method and program
[0001] The present disclosure relates to a security assurance system, a security assurance method, and a program.
[0002] Businesses that handle personal data such as IDs and passwords are responsible for safely storing the data entrusted to them. Conventionally, particularly with regard to passwords, a countermeasure against Rainbow Table Attacks in the event of data leakage has been to minimize the impact of data leakage by using a hash function or KDF (key derivation function) and salting (random number generation) / stretching (repeated application). Users of programs provided by businesses want to know whether the above-mentioned countermeasures are being properly implemented for the data (confidential information) they have entrusted to the business.
[0003] Proof-Carrying Code (PCC) is known as a technology for distributing a program together with proof that the program operates correctly and safely. For example, Non-Patent Document 1 proposes a technology that uses PCC to verify that a program does not contain any unexpected communication functions (more specifically, a safety requirement that "when a communication API is called, its arguments do not contain confidential information").
[0004] Ren Matsuda, Misato Nakabayashi, Tetsuya Okuda, "Assuring Security Against Unauthorized Communication on Network Devices Using Proof-Carrying Code," Proceedings of the Computer Security Symposium 2022, pp.635-642, 2022.
[0005] However, the technology described in Non-Patent Document 1 aims to ensure security by preventing confidential information from being transmitted through a backdoor, but cannot guarantee security by ensuring that confidential information is safely stored in a program.
[0006] The present disclosure has been made in consideration of the above points, and provides a technology that can guarantee the safety of storing confidential information in a program.
[0007] A security assurance system according to one aspect of the present disclosure is a security assurance system for ensuring security by indicating that confidential information in a target program is hashed when the confidential information is written externally, and includes an analysis unit that performs lexical analysis and syntactic analysis on the target program to create a syntax tree of a predetermined format, a verification logical formula generation unit that takes the syntax tree as input and generates a verification logical formula for verifying that the target program satisfies the security level using predetermined generation rules, a proof generation unit that takes the verification logical formula as input and generates a proof that indicates that the verification logical formula is correct using predetermined inference rules, and a proof verification unit that takes the verification logical formula and the proof as input and verifies whether the proof is a correct proof of the verification logical formula using the inference rules.
[0008] A technique is provided that can guarantee the safety of storing confidential information in a program.
[0009] FIG. 1 is a diagram showing an example of an inference rule expressed in the input format of Prolog. FIG. 2 is a diagram showing an example of the overall configuration of a security assurance system according to the present embodiment. FIG. 3 is a diagram showing an example of the hardware configuration of a prover device according to the present embodiment. FIG. 4 is a diagram showing an example of the hardware configuration of a verifier device according to the present embodiment. FIG. 5 is a diagram showing an example of the functional configuration of a prover device according to the present embodiment. FIG. 6 is a sequence diagram showing an example of security requirement proof and verification processing according to the present embodiment.
[0010] An embodiment of the present invention will be described below.
[0011] <PCC> PCC is a technology that, when distributing a program, also distributes proof that the program operates correctly and safely (see References 1-3, etc.).
[0012] PCC consists of three elements: a verification logic formula generator (VCGen), a proof generator (Proof-Gen), and a proof verifier (ProofCheck). The verification logic formula generator takes the target program as input and outputs a logical formula called a verification logic formula, which has the property that "if this verification logic formula is true, the program satisfies certain requirements." The proof generator takes the verification logic formula as input and outputs a proof that the logical formula is correct. The proof verifier takes the verification logic formula and its proof as input and outputs the verification result of the proof (that is, whether or not the proof is a correct proof of the verification logic formula).
[0013] While digital signatures and other methods can only guarantee the source of a program, PCCs can guarantee the program's operation. Furthermore, generally, the computational cost of verifying a proof is lower than that of creating a proof. With PCCs, the creator (or provider) of a program creates a verification formula and its proof, and the user of the program verifies the proof. This allows the user of the program to confirm, at low cost, that the program satisfies certain predefined requirements. Hereinafter, the person who creates the verification formula and its proof (e.g., the creator or provider of the program) will be referred to as the "prover," and the person who verifies the proof (e.g., the user of the program) will be referred to as the "verifier."
[0014] <Proposed Method> Hereinafter, a method will be proposed that uses PCC to ensure that confidential information is safely stored in a program (hereinafter also referred to as a "target program").
[0015] <<Security Requirement>> The security requirement is that the target program stores confidential information such as passwords after hashing it in the correct procedure. In other words, the security requirement is that the target program always properly hashes confidential information when it is written externally.
[0016] <Target Program> The target program handled by this proposed method is defined below.
[0017] Here, P represents a program and e represents an expression. In the program P, skip represents an operation of doing nothing, x:=e represents an assignment operation, y:=hash(x) represents a hashing operation of the variable x, write(x) represents an operation of writing the variable x to an external device (for example, a database), and if x then P 1 else P 2 If variable x is true, then P 1 , otherwise P 2 The elements x, ic, ip, bop(e 1 , e 2 ) represent variables, private information, public information, and binary operations (e.g., addition, multiplication, etc.), respectively.
[0018] For example, a target program P that assigns public information a to a variable x, hashes it, and writes it out externally can be written as follows:
[0019] x:=a; y:=hash(x); write(y); skip. When a program written in another programming language (for example, C language) is used as the target program, it is necessary to convert it into the format defined by the above equation 1 using lexical and syntactic analysis.
[0020] It is assumed that it is predetermined (for example, labeled) whether a value appearing in data is information that should be kept secret (ic) or information that may be made public (ip). For example, it is assumed that the method of obtaining the value is predefined, such that a value obtained from a certain specified data is confidential information, and a value obtained from a certain specified directory is public information. Alternatively, for example, it is assumed that variables in which confidential information is stored in the target program are prelisted.
[0021] It is also assumed that APIs (Application Programming Interfaces) that realize hashing operations and write operations are determined in advance. For example, it is assumed that a hashing operation is performed when a certain predetermined hashing API is called, and similarly, it is assumed that a write operation is performed when a certain predetermined file writing API or a certain predetermined database writing API is called. Alternatively, it is assumed that APIs that realize hashing operations and write operations are listed in advance.
[0022] <PCC Design> Types and inference rules Types are defined as follows:
[0023] Here, Pb represents the type of information that may be made public (hereinafter referred to as the public type), and Cf represents the type of information that must be kept secret (hereinafter referred to as the secret type).
[0024] All information that must be kept secret (ic) has type Cf, and all information that may be made public (ip) has type Pb. The default type for all variables is Pb, and the type Cf is assigned to the secret information ic.
[0025] To perform type inference, the following inference rules VAR, HASH1, HASH2, BOP1, BOP2, BOP3, and BOP4 are defined.
[0026]
[0027]
[0028]
[0029]
[0030]
[0031]
[0032] Here, Γ represents a type environment, and the following represents a type judgment:
[0033] The type judgment shown in the above equation (10) means that "the expression e has the type t under the type environment Γ."
[0034] Intuitively, the inference rule VAR means a typing rule in a type environment, the inference rules HASH1 and HASH2 mean that the hash value of any value has the type of public information, and the inference rules BOP1, BOP2, BOP3, and BOP4 mean that if the binary operation takes at least one private piece of information as an argument, then the result of the binary operation is also private information, and if both arguments of the binary operation are public information, then the result of the binary operation is also public information.
[0035] The inference rules shown in the above equations 3 to 9 can be expressed in the Prolog input format as shown in Figure 1. In the example shown in Figure 1, "1" to "7" respectively represent the inference rules VAR, HASH1, HASH2, BOP1, BOP2, BOP3, and BOP4 expressed in the Prolog input format.
[0036] Verification logic formula generator The verification logic formula generator (VCGen) takes as input the target program (more precisely, data obtained by converting the target program into the format defined in Equation 1 above through lexical and syntactic analysis) and outputs a verification logic formula that has the property that "if this logic formula can be derived using inference rules, the target program satisfies the safety requirements." In this proposed method, the generation rules for verification logic formulas are defined as follows:
[0037] For example, consider the following target program P, which assigns public information a to a variable x, hashes it, and writes it out externally.
[0038] x:=a; y:=hash(x); write(y); skip. In this case, the verification logical formula for the target program P is as follows:
[0039] Here, since it is assumed that a is public information, a:Pb. When t = Pb, the logical formula after the existence symbol is true, so the verification logical formula shown in the above equation 12 is true (i.e., the target program P satisfies the safety requirements).
[0040] Below, we will explain a safety assurance system 1 that can guarantee the safety of confidential information (e.g., passwords) being safely stored in a target program P by making it possible to verify whether the target program P satisfies safety requirements using the above-mentioned proposed method.
[0041] <Example of Overall Configuration> An example of the overall configuration of a security assurance system 1 according to this embodiment is shown in Fig. 2. As shown in Fig. 2, the security assurance system 1 according to this embodiment includes a prover device 10 and a verifier device 20. Furthermore, the prover device 10 and the verifier device 20 are communicatively connected via a communication network 30 including, for example, the Internet.
[0042] The prover device 10 is a device used or managed by a prover (e.g., a program creator or provider) that creates a verification logical formula and its proof. The prover device 10 can be realized by various computers or computer systems, such as a PC (personal computer), a general-purpose server, etc.
[0043] The verifier device 20 is a device used or managed by a verifier (e.g., a program user) who verifies a proof. The verifier device 20 can be realized by various computers or computer systems, such as a PC, a general-purpose server, a smartphone, a tablet terminal, a wearable device, etc.
[0044] The overall configuration of the security assurance system 1 shown in Fig. 2 is an example and is not limited to this. For example, in the example shown in Fig. 1, one prover device 10 and one verifier device 20 are shown, but there may be multiple prover devices 10, and similarly, there may be multiple verifier devices 20.
[0045] <Hardware Configuration Example> Hereinafter, a hardware configuration example of the prover device 10 and the verifier device 20 included in the security assurance system 1 according to this embodiment will be described.
[0046] <<Prover Device 10>> An example of the hardware configuration of the prover device 10 according to this embodiment is shown in Fig. 3. As shown in Fig. 3, the prover device 10 according to this embodiment has an input device 11, a display device 12, an external I / F 13, a communication I / F 14, a RAM (Random Access Memory) 15, a ROM (Read Only Memory) 16, an auxiliary storage device 17, and a processor 18. Each of these pieces of hardware is connected to each other via a bus 19 so as to be able to communicate with each other.
[0047] The input device 11 is, for example, a keyboard, a mouse, a touch panel, a physical button, etc. The display device 12 is, for example, a display, a display panel, etc. Note that the prover device 10 may not have at least one of the input device 11 and the display device 12, for example.
[0048] The external I / F 13 is an interface with an external device such as a recording medium 13 a. Examples of the recording medium 13 a include a CD (Compact Disc), a DVD (Digital Versatile Disk), an SD memory card (Secure Digital memory card), and a USB (Universal Serial Bus) memory card.
[0049] The communication I / F 14 is an interface for connecting the prover device 10 to the communication network 30. The RAM 15 is a volatile semiconductor memory (storage device) that temporarily stores programs and data. The ROM 16 is a non-volatile semiconductor memory (storage device) that can store programs and data even when the power is turned off. The auxiliary storage device 17 is a storage device (storage device) such as an HDD (Hard Disk Drive), an SSD (Solid State Drive), or a flash memory. The processor 18 is various types of arithmetic devices such as a CPU (Central Processing Unit) or a GPU (Graphics Processing Unit).
[0050] 3 is an example, and the hardware configuration of the prover device 10 is not limited to this. For example, the prover device 10 may have multiple auxiliary storage devices 17 or multiple processors 18, may not have some of the hardware shown in the figure, or may have various hardware other than the hardware shown in the figure.
[0051] <Verifier Device 20> An example of the hardware configuration of the verifier device 20 according to this embodiment is shown in Fig. 4. As shown in Fig. 4, the verifier device 20 according to this embodiment includes an input device 21, a display device 22, an external I / F 23, a communication I / F 24, RAM 25, ROM 26, an auxiliary storage device 27, and a processor 28. Each of these pieces of hardware is connected to each other via a bus 29 so as to be able to communicate with each other.
[0052] The input device 21 is, for example, a keyboard, a mouse, a touch panel, a physical button, etc. The display device 22 is, for example, a display, a display panel, etc. Note that the verifier device 20 may not have at least one of the input device 21 and the display device 22, for example.
[0053] The external I / F 23 is an interface with an external device such as a recording medium 23a, etc. Examples of the recording medium 23a include a CD, a DVD, an SD memory card, and a USB memory card.
[0054] The communication I / F 24 is an interface for connecting the verifier device 20 to the communication network 30. The RAM 25 is a volatile semiconductor memory (storage device) that temporarily stores programs and data. The ROM 26 is a non-volatile semiconductor memory (storage device) that can store programs and data even when the power is turned off. The auxiliary storage device 27 is a storage device (storage device) such as an HDD, SSD, or flash memory. The processor 28 is a variety of arithmetic devices such as a CPU or GPU.
[0055] 4 is an example, and the hardware configuration of the verifier device 20 is not limited to this. For example, the verifier device 20 may have multiple auxiliary storage devices 27 or multiple processors 28, may not have some of the hardware shown in the figure, or may have various hardware other than the hardware shown in the figure.
[0056] <Example of Functional Configuration> An example of the functional configuration of the prover device 10 and the verifier device 20 included in the security assurance system 1 according to this embodiment will now be described.
[0057] <<Prover Device 10>> An example of the functional configuration of the prover device 10 according to this embodiment is shown in Fig. 5. As shown in Fig. 5, the prover device 10 according to this embodiment has an input unit 101, a lexical analysis unit 102, a syntax analysis unit 103, a verification logical formula generation unit 104, a proof generation unit 105, and a communication unit 106. Each of these units is realized, for example, by a process in which one or more programs installed in the prover device 10 are executed by a processor 18 or the like. It is assumed that the prover device 10 is provided with a target program written in another programming language (for example, C language).
[0058] The input unit 101 inputs a given target program.
[0059] The lexical analysis unit 102 performs lexical analysis on the target program input by the input unit 101. In the lexical analysis, the target program is broken down into the smallest units (tokens) that are meaningful in terms of a programming language. As a result, a token string is obtained by breaking down the target program into token units.
[0060] The syntax analysis unit 103 performs syntax analysis on the token sequence obtained by the lexical analysis unit 102. In the syntax analysis, a data structure called a syntax tree or the like is created from the token sequence in accordance with the format defined by the above equation 1. This results in a syntax tree that expresses the target program in the format defined by the above equation 1.
[0061] The verification logical formula generation unit 104 is a verification logical formula generator (VCGen), which takes as input the syntax tree obtained by the syntax analysis unit 103 (i.e., data expressing the target program in the format defined by the above equation 1) and generates a verification logical formula according to the generation rules shown in the above equation 11.
[0062] The proof generation unit 105 is a proof generator (Proof-Gen), which receives the verification logical formula generated by the verification logical formula generation unit 104 as input and generates a proof that the verification logical formula is correct according to the inference rules shown in the above equations 3 to 9. Note that the proof generation unit 105 may be, for example, an existing proof generator (Proof-Gen) realized by Prolog or the like.
[0063] The communication unit 106 transmits the target program input by the input unit 101, the verification logical formula generated by the verification logical formula generation unit 104, and the proof generated by the proof generation unit 105 to the verifier device 20.
[0064] <Verifier Device 20> An example of the functional configuration of the verifier device 20 according to this embodiment is shown in Fig. 6. As shown in Fig. 6, the verifier device 20 according to this embodiment has a communication unit 201, a proof verification unit 202, and an output unit 203. Each of these units is realized by, for example, processing in which one or more programs installed in the verifier device 20 are executed by a processor 28 or the like.
[0065] The communication unit 201 receives the target program, the verification logical formula, and the proof sent from the prover device 10 .
[0066] Proof verification unit 202 is a proof verification device (ProofCheck) that receives as input the verification logical formula and proof received by communication unit 201 and generates a verification result of the proof (i.e., whether the proof is a correct proof of the verification logical formula) according to the inference rules shown in above equations 3 to 9. Note that proof verification unit 202 may be, for example, an existing proof verification device (ProofCheck) realized by Prolog or the like.
[0067] The output unit 203 outputs the verification result generated by the proof verification unit 202 to a predetermined output destination. Note that the output destination is not particularly limited, and examples thereof include a storage area such as the auxiliary storage device 27, a display device 22 such as a display, other devices, equipment, and terminals connected via a communication network, etc. <Safety Requirement Proof and Verification Process> Hereinafter, the safety requirement proof and verification process according to this embodiment will be described with reference to FIG. 7 .
[0068] First, the input unit 101 of the prover device 10 inputs a given target program (step S101).
[0069] Next, the lexical analysis unit 102 of the prover device 10 performs lexical analysis on the target program input in step S101 above to create a token string (step S102).
[0070] Next, the syntax analysis unit 103 of the prover device 10 performs syntax analysis on the token sequence created in step S102 above, and creates a syntax tree that expresses the target program input in step S101 above in the format defined by equation 1 above (step S103).
[0071] Next, the verification logical formula generation unit 104 of the prover device 10 uses the syntax tree created in step S103 above (i.e., data expressing the target program in the format defined in equation 1 above) as input and generates a verification logical formula using the generation rules shown in equation 11 above (step S104).
[0072] Next, the proof generation unit 105 of the prover device 10 takes the verification logical formula generated in step S104 as input and generates a proof that the verification logical formula is correct using the inference rules shown in equations 3 to 9 above (step S105).
[0073] Then, the communication unit 106 of the prover device 10 transmits the target program input in step S101 above, the verification logical formula generated in step S105 above, and the proof generated in step S105 above to the verifier device 20 (step S106).
[0074] The communication unit 201 of the verifier device 20 receives the target program, the verification formula, and the proof sent from the prover device 10 (step S107).
[0075] Next, the proof verification unit 202 of the verifier device 20 takes the verification logical formula and proof received in step S107 above as input and generates a verification result for the proof (i.e., whether the proof is a correct proof of the verification logical formula or not) using the inference rules shown in equations 3 to 9 above (step S108).
[0076] Then, the output unit 203 of the verifier device 20 outputs the verification result generated in step S108 to a predetermined output destination (step S109).
[0077] <Summary> As described above, the security assurance system 1 according to this embodiment can generate a verification logical formula and its proof for verifying that a target program satisfies the security requirement that "confidential information is always appropriately hashed when written externally" in the prover device 10. Furthermore, the security assurance system 1 according to this embodiment can verify the verification logical formula and the proof in the verifier device 20, and confirm that the target program satisfies the security requirement.
[0078] This enables, for example, a business operator that handles confidential information such as personal data to guarantee the safety of the target program for service use, and a contractor vendor that develops a target program that processes confidential information such as personal data to guarantee the safety of the target program to the contractor. This enables, for example, service users to trust business operators that handle confidential information such as personal data, and contractors to trust contractor vendors that develop target programs that process confidential information such as personal data.
[0079] The present invention is not limited to the above-described specifically disclosed embodiments, and various modifications, changes, and combinations with known technologies are possible without departing from the scope of the claims.
[0080] [References] Reference 1: Necula, G. C.: Proof-Carrying Code, Conference Record of POPL'97: The 24th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, Papers Presented at the Symposium, Paris, France, 15-17 January 1997 (Lee, P., Henglein, F. and Jones, N. D., eds.), ACM Press, pp. 106-119 (1997). Reference 2: Necula, G. C.: Proof-carrying code: design, implementation and applications (abstract), Proceedings of the 2nd international ACM SIGPLAN conference on on Principles and practice of declarative programming, Montreal, Canada, September 20-23, 2000 (Gabbrielli, M. and Pfenning, F., eds.), ACM, pp. 175-177 (2000). Reference 3: Necula, G. C. and Lee, P.: Safe, Untrusted Agents Using Proof-Carrying Code, Mobile Agents and Security (Vigna, G., ed.), Lecture Notes in Computer Science, Vol. 1419, Springer, pp. 61-91 (1998).
[0081] 1 Security assurance system 10 Prover device 11 Input device 12 Display device 13 External I / F 13a Recording medium 14 Communication I / F 15 RAM 16 ROM 17 Auxiliary storage device 18 Processor 19 Bus 20 Verifier device 21 Input device 22 Display device 23 External I / F 23a Recording medium 24 Communication I / F 25 RAM 26 ROM 27 Auxiliary storage device 28 Processor 29 Bus 30 Communication network 101 Input unit 102 Lexical analysis unit 103 Syntax analysis unit 104 Verification logical formula generation unit 105 Proof generation unit 106 Communication unit 201 Communication unit 202 Proof verification unit 203 Output unit
Claims
1. A safety assurance system for ensuring security by indicating that secret information in a target program is hashed when the secret information is written out externally, the safety assurance system having: an analysis unit that performs lexical analysis and syntactic analysis on the target program to create a syntax tree of a prescribed format; a verification logical formula generation unit that takes the syntax tree as input and generates a verification logical formula for verifying that the target program satisfies the security requirement, using prescribed generation rules; a proof generation unit that takes the verification logical formula as input and generates a proof indicating that the verification logical formula is correct, using prescribed inference rules; and a proof verification unit that takes the verification logical formula and the proof as input and verifies, using the inference rules, whether the proof is a correct proof of the verification logical formula.
2. The format is as follows: P is the target program, e is an expression, hashing operation is hash(·), writing operation to the outside is write(·), operation of doing nothing is skip, binary operation is bop(·,·), variable is x, confidential information is ic, and public information is ip. P::=skip|x:=e;P|y:=hash(x);P|write(x);P|if x then P 1 else P 2 e:: =x|ic|ip|bop(e 1 , e 2 2. The safety assurance system according to claim 1 , 3. A security assurance system as described in claim 1 or 2, wherein the inference rules include: a rule for assigning to variables of the target program either a confidential type indicating that the value stored in the variable is confidential information, or a public type indicating that the value stored in the variable is public information; a rule indicating that the hash value of any value has a public type; a rule indicating that if at least one of the arguments of a binary operation is confidential information, the result of the binary operation is confidential information; and a rule indicating that if both of the arguments of the binary operation are public information, the result of the binary operation is public information.
4. The generation rule is as follows: VCGen(•) is a verification formula generator that generates the verification formula, Pb is the public type, and Cb is the private type. Γ (skip):=true VCGen Γ (x:=e;P):=∃t. (Expression e has type t in type environment Γ) ∧VCGen Γ{x:t} (P) VCGen Γ (y:=hash(x);P):=VCGen Γ{y:Pb} (P) VCGen Γ (write(x); P):=(variable x has public type Pb in type environment Γ) VCGen Γ (P) VCGen Γ (if x then P 1 else P 2 ): =VCGen Γ (P 1 ) ∧VCGen Γ (P 2 4. The safety assurance system according to claim 3, wherein 5. A safety assurance method for assuring security indicating that when secret information in a target program is written out to the outside, the secret information is hashed, the safety assurance system executing the following steps: an analysis step of performing lexical analysis and syntactic analysis on the target program to create a syntax tree of a prescribed format; a verification logical formula generation step of using the syntax tree as input to generate a verification logical formula for verifying that the target program satisfies the security, according to prescribed generation rules; a proof generation step of using the verification logical formula as input to generate a proof indicating that the verification logical formula is correct, according to prescribed inference rules; and a proof verification step of using the verification logical formula and the proof as input to verify whether the proof is a correct proof of the verification logical formula, according to the inference rules.
6. A program for a security assurance system for ensuring security, which indicates that when secret information in a target program is written out to the outside, the secret information is hashed, the program executing: an analysis procedure for performing lexical analysis and syntactic analysis on the target program to create a syntax tree of a prescribed format; a verification logical formula generation procedure for taking the syntax tree as input and generating a verification logical formula for verifying that the target program satisfies the security, according to prescribed generation rules; a proof generation procedure for taking the verification logical formula as input and generating a proof indicating that the verification logical formula is correct, according to prescribed inference rules; and a proof verification procedure for taking the verification logical formula and the proof as input and verifying whether the proof is a correct proof of the verification logical formula, according to the inference rules.
Citation Information
Patent Citations
Method and system for delivering certification-born program
JP2006197323A
Source code equivalence verifying device, and source code equivalence verifying method
WO2016038741A1
