JP5346608B2 - Information processing apparatus and file verification system - Google Patents

Description

  The present invention relates to an information processing apparatus that improves security. The present invention also relates to a file verification system that verifies the integrity of a file in the information processing apparatus.

  There have been many incidents of intrusion into public servers and tampering with data and applications in public servers. Many public servers are operated in the data center, and the server administrator accesses the public server by remote access, starts the verification application, and the verification result output from the verification application shows the trace of intrusion in the public server. Verify whether or not tampering (remote verification).

  However, once the intrusion to the server is allowed, the integrity of the verification result, such as an attack that embeds Rootkit in the kernel and falsifies the response, an attack that falsifies the response by falsifying the verification application, or an attack that falsifies the verification result There is a problem that cannot be secured. On the other hand, many modern servers have a tamper-resistant chip called Trusted Platform Module (TPM), and the integrity of the kernel and the application (not tampered) at server startup. ) Was a remote verification mechanism.

  The TPM is a chip having an area that cannot be accessed from the outside, and an encryption key and an electronic signature program are stored in the secure area. The TPM stores the state of the kernel and application as a hash value at the timing when the host starts, and returns a hash value with an electronic signature in accordance with a request by remote access. As a result, the remotely accessed server administrator can grasp the state of the host at the time of activation. The processing executed by TPM is independent of the server kernel. As a result, even if the kernel is tampered with, a mechanism that is not affected by it is realized.

  As a mechanism for guaranteeing the integrity of a running kernel, there is a technique called SecVisor (see Non-Patent Document 1). SecVisor implements a mechanism that prohibits access from the user space (user application) to the kernel area running on the memory. Furthermore, SecVisor has a mechanism that verifies the state of the kernel when the kernel is booted and continues the booting process only when the integrity of the kernel is confirmed. Thus, SecVisor can guarantee the integrity of the booted and running kernel.

  As a mechanism for guaranteeing the integrity of a user application, there is a technique called DigSig (see Non-Patent Document 2). DigSig implements control that activates only a trusted complete application by applying an electronic signature to a user application and authenticating with the electronic signature when the application is activated.

A. Seshadri, M. Luk, N. Qu, and A. Perrig, “SecVisor: A Tiny Hypervisor to Provide Lifetime Kernel Code Integrity for Commodity OSes,” 21st ACM Symposium on Operating Systems Principles, October, 2007 A. Apvrille, M. Pourzandi, D. Gordon, V. Roy, "Stop Malicious Code Execution at Kernel Level," Linux World, Vol.2, No.1, January 2004

  However, TPM can guarantee the integrity of the kernel and the application only at the time of startup, and cannot guarantee the integrity of the kernel and the application when receiving an intrusion due to a buffer overflow attack on a running server. SecVisor can always guarantee the integrity of the kernel, but cannot guarantee the integrity of the user application. DigSig can guarantee the integrity of the application at startup, but cannot guarantee the integrity of the kernel.

  The present invention has been made in view of the above-described problems, and provides an information processing apparatus and a file verification system capable of starting a user application whose integrity is guaranteed from a kernel whose integrity is guaranteed. For the purpose.

  The present invention has been made to solve the above-described problems, and includes program storage means for storing an OS kernel and a user application program, a kernel area for storing the kernel program, and the user application program. A memory having a user area in which is stored, a kernel verification unit that verifies the integrity of the kernel when the kernel is started, a CPU that executes processing according to a program stored in the memory, and the user application And prohibiting means for prohibiting data writing to a kernel area, and when the CPU can confirm that the kernel has not been tampered with by the kernel verifying means, the CPU stores the program of the kernel in the program storing means. To the kernel area And starting the kernel, and verifying the integrity of the user application when the user application is started by the kernel, and confirming that the user application has not been tampered with. An information processing apparatus that executes a process of reading a program from the program storage unit into the user area and starting the user application.

  The information processing apparatus according to the present invention further includes file storage means for storing a file, and the CPU further executes processing for calculating a hash value of the file by the user application.

  In the information processing apparatus according to the present invention, the CPU further executes processing for applying an electronic signature to the hash value by the kernel.

  The present invention is also a file verification system including an information processing apparatus and a file verification apparatus, the information processing apparatus comprising: a program storage unit that stores an OS kernel and a user application program; and the kernel program According to the program stored in the memory, a memory having a kernel area to be stored, a user area in which the program of the user application is stored, kernel verification means for verifying the integrity of the kernel when the kernel is started A CPU that executes processing; a prohibiting unit that prohibits writing of data to the kernel area from the user application; and a file storage unit that stores a file. Not being tampered with If it is confirmed, the process of reading the kernel program from the program storage unit into the kernel area and starting the kernel, and the kernel verifies the integrity of the user application when the user application is started, When it is confirmed that the user application has not been tampered with, a process of reading the user application program from the program storage unit into the user area and starting the user application; A process of calculating a hash value; a process of applying an electronic signature to the hash value by the kernel; and a process of transmitting the hash value and the electronic signature to an external terminal by the user application. The file verification apparatus executes a reception unit that receives the hash value and the electronic signature from the information processing apparatus, a first verification unit that verifies the integrity of the file based on the hash value, and A file verification system comprising: second verification means for verifying the integrity of the hash value based on an electronic signature.

  According to the present invention, when it is confirmed that the kernel has not been tampered with, the kernel is started, and access from the user application to the kernel area is prohibited while the kernel is running. Kernel integrity is guaranteed. In addition, since it is confirmed that the user application has not been tampered with by the kernel whose integrity is guaranteed, the integrity of the user application at the time of activation is guaranteed. Therefore, it is possible to start a user application whose integrity is guaranteed from a kernel whose integrity is guaranteed.

It is a block diagram which shows the structure of the information processing apparatus by one Embodiment of this invention. FIG. 6 is a reference diagram illustrating a state of processing when a kernel is activated in an embodiment of the present invention. It is a reference figure which shows the mode of a process when starting a user application from the kernel by which completeness was confirmed. FIG. 10 is a reference diagram illustrating a process of prohibiting access to a kernel area in an embodiment of the present invention. FIG. 10 is a reference diagram illustrating a process of prohibiting access to a kernel area in an embodiment of the present invention. In one Embodiment of this invention, it is a reference figure which shows the mode of a process when the application for verification confirms the state of a system file.

  Hereinafter, embodiments of the present invention will be described with reference to the drawings. FIG. 1 shows the configuration of an information processing apparatus according to an embodiment of the present invention. The information processing apparatus shown in FIG. 1 includes an HDD (Hard Disk Drive) 10, a memory 11, a CPU 12, a DMA 13, a memory management unit 14, and a kernel activation control unit 15. These components are connected to the bus 20.

  The HDD 10 stores a kernel program that defines processing executed by a kernel that forms the basis of an OS (operating system), a system file required for operating the OS, a user application program that defines processing executed by various applications, and the like. The memory 11 temporarily stores programs executed by the CPU 12 and data necessary for calculation. The memory 11 includes a kernel area 110 in which a kernel program is stored and a user area 111 in which a user application program is stored. Further, the kernel area 110 includes a program area in which the kernel program itself is stored and a data area in which data necessary for the activated kernel program to perform processing is stored.

  The CPU 12 implements various functions by executing processing according to various programs stored in the memory 11. When the kernel program is read from the HDD 10 into the kernel area 110 of the memory 11 and the kernel is activated, the CPU 12 executes processing related to kernel functions such as process management and memory management. When the user application program is read from the HDD 10 into the user area 111 of the memory 11 and the user application is activated, the CPU 12 executes processing related to the function of the user application such as image processing and data communication.

  The DMA (Direct Memory Access) 13 is hardware capable of transferring data between the memory 11 and hardware without using the CPU 12. The memory management unit 14 manages access to the memory 11. Access to the memory 11 by the CPU 12 is managed by an MMU (Memory Management Unit) in the memory management unit 14, and access to the memory 11 by the DMA 13 is managed by an IOMMU (Input / Output MMU) in the memory management unit 14. The Some functions (for example, MMU) in the memory management unit 14 may be mounted on the CPU 12. The kernel activation control unit 15 controls the activation of the kernel when the information processing apparatus is activated.

  Next, the operation of the information processing apparatus according to the present embodiment will be described. In this embodiment, (1) a complete kernel is started, (2) a complete user application is started by a complete kernel, (3) the integrity of the running kernel is ensured, and (4) a complete verification application is provided. A complete kernel electronic signature for the result of checking the status of the file is realized.

(1) Complete Kernel Activation When the information processing apparatus is activated, the CPU 12 activates the BIOS by reading a BIOS (Basic Input / Output System) program from a ROM (not shown) into the kernel area 110 of the memory 11. Subsequently, the CPU 12 starts the boot loader by reading the boot loader program from the MBR (Master Boot Record) of the HDD 10 into the kernel area 110 of the memory 11 by the BIOS. Subsequently, the CPU 12 starts the kernel by reading the kernel program from the HDD 10 into the kernel area 110 of the memory 11 by the boot loader. The kernel is started as described above.

  FIG. 2 shows a state of processing when starting the kernel. The kernel activation control unit 15 is a tamper-resistant chip that cannot be tampered with from the outside, and includes a CPU that executes processing and a memory that stores data. The kernel activation control unit 15 is realized by the TPM described above. Hereinafter, the operation of the kernel activation control unit 15 will be described.

  When the information processing apparatus is activated for the first time, the kernel activation control unit 15 calculates a hash value from each program of the BIOS 21, the boot loader 22, and the kernel 23. The hash value is a value calculated using a hash function, and is a value that is unique with respect to the input value. The kernel activation control unit 15 holds the calculated hash values of the BIOS 21, the boot loader 22, and the kernel 23 in an internal memory. At this point, it is assumed that the BIOS 21, the boot loader 22, and the kernel 23 have not been tampered with.

  At the second and subsequent boots, the kernel boot control unit 15 first calculates the hash value of the BIOS 21 program and compares the hash value with the hash value of the BIOS 21 program stored in the internal memory. If both hash values are different, there is a possibility that the BIOS 21 has been tampered with, so the kernel activation control unit 15 sends a command to the CPU 12 to stop activation of the BIOS 21. Receiving this command, the CPU 12 stops the activation of the BIOS 21.

  On the other hand, when both hash values are the same, since it has been confirmed that the BIOS 21 has not been tampered with, the kernel activation control unit 15 passes the processing to the CPU 12, and the CPU 12 activates the BIOS 21. Subsequently, the kernel activation control unit 15 calculates the hash value of the program of the boot loader 22 and compares the hash value with the hash value of the program of the boot loader 22 held in the internal memory. If both hash values are different, there is a possibility that the boot loader 22 has been tampered with, so the kernel activation control unit 15 sends an instruction to the CPU 12 to stop activation of the boot loader 22. Receiving this command, the CPU 12 stops the boot loader 22 from being activated.

  On the other hand, when both hash values are the same, since it has been confirmed that the boot loader 22 has not been tampered with, the kernel activation control unit 15 passes the processing to the CPU 12, and the CPU 12 activates the boot loader 22. Subsequently, the kernel activation control unit 15 calculates a hash value of the program of the kernel 23 and compares the hash value with the hash value of the program of the kernel 23 held in the internal memory. If both hash values are different, the kernel 23 may have been tampered with, so the kernel activation control unit 15 sends to the CPU 12 an instruction to stop activation of the kernel 23. Receiving this command, the CPU 12 stops the activation of the kernel 23.

  On the other hand, when both hash values are the same, since it has been confirmed that the kernel 23 has not been tampered with, the kernel activation control unit 15 passes the processing to the CPU 12, and the CPU 12 activates the kernel 23. As described above, the kernel 23 whose integrity is guaranteed can be started. In the above, a method to start a complete kernel by TPM is realized, but even when SecVisor described above is used, a method to start the kernel after confirming the integrity of the kernel by the hash value is also realized. be able to.

(2) Activation of Complete User Application with Complete Kernel FIG. 3 shows the processing when the user application is activated from the kernel whose integrity has been confirmed as described above. In FIG. 3 and FIG. 6 described later, the kernel space 30 and the user space 40 are configured to include resources of the CPU 12 and the memory 11.

  The kernel space 30 includes a resource of the CPU 12 that executes processing for realizing a function as a kernel, and a kernel area 110 that is allocated to the memory 11 for executing the processing. Further, the user space 40 includes a resource of the CPU 12 that executes processing for realizing a function as a user application, and a user area 111 that is allocated to the memory 11 for executing the processing.

  The activation control unit 31 belonging to the kernel space 30 detects a system call (activation request) made to the kernel when the process activates the user application, and controls the activation of the user application. Linux (registered trademark) is implemented with Linux (registered trademark) Security Module (LSM), which is a framework for extending security functions in the kernel. In LSM, when a file or process is operated, a monitoring point is provided to call a security verification mechanism defined by the user to verify authority and generate a log. The activation control unit 31 belonging to the kernel space 30 corresponds to this LSM monitoring point.

  The verification unit 32 verifies the integrity of the user application program when the activation control unit 31 detects a user application activation request. In order to perform this verification, the verification unit 32 has a public key Kp necessary for verification. While the activation control unit 31 and the verification unit 32 are operating, these entities (programs) are stored in the program area in the kernel area 110 of the memory 11. In addition, the application program stored in the HDD 10 is added with an electronic signature in which the hash value of the application program is encrypted with a secret key corresponding to the public key Kp of the verification unit 32.

  The user application is started as follows. First, a process on the kernel space 30 or the user space 40 generates a system call (startup request) to start the user application (step S100). The activation control unit 31 detects this activation request and transfers the processing to the verification unit 32 (step S110). The verification unit 32 reads the user application program requested to be activated from the HDD 10 into the data area in the kernel area 110 of the memory 11 (step S120).

  The verification unit 32 decrypts the electronic signature added to the user application with the public key Kp to obtain a hash value. The verification unit 32 calculates a hash value from the user application program. Then, the verification unit 32 verifies the integrity of the user application by comparing the hash value obtained by decrypting the electronic signature with the hash value calculated from the user application program (step S130).

  If both hash values are different, the user application program may have been tampered with. If both hash values match, the integrity of the user application program is guaranteed. The verification unit 32 notifies the activation control unit 31 of the verification result (step S140).

  Upon receiving the notification, the activation control unit 31 controls the activation of the application based on the verification result. If tampering is detected as a result of the verification, the activation control unit 31 stops the application activation process. If the integrity of the user application program can be confirmed as a result of the verification, the activation control unit 31 moves the user application program stored in the data area in the kernel area 110 to the user area 111, and The application is activated (step S150).

  The integrity of the boot control unit 31 and the verification unit 32 in the kernel space 30 is guaranteed at the time of booting the kernel, and the integrity of the running kernel is also guaranteed as will be described later. Thus, the integrity of the user application started from the kernel space 30 is guaranteed. A method similar to the above is also realized by DigSig.

(3) Ensuring the integrity of the operating kernel The integrity of the operating kernel is ensured by the following three methods. Even if only one of these methods is implemented, the effect can be obtained, but by implementing all the methods, the integrity of the kernel can be further improved. In addition, methods similar to these methods are realized by SecVisor.

  FIG. 4 shows the first method. In the memory 11, an area allocated as the kernel area 110 is fixed in advance, and the memory management unit 14 holds the address of the kernel area 110. Since the DMA 13 accesses the memory 11, when the address of the memory 11 to be accessed is output to the memory management unit 14, the memory management unit 14 compares the address output from the DMA 13 with the address of the kernel area 110.

  When the address output from the DMA 13 does not correspond to the address of the kernel area 110, that is, when the DMA 13 tries to access an area other than the kernel area 110 (access 50 in FIG. 4), the memory management unit 14 permits the access. Further, when the address output from the DMA 13 corresponds to the address of the kernel area 110, that is, when the DMA 13 tries to access the kernel area 110 (access 51 in FIG. 4), the memory management unit 14 prohibits the access. In this way, it is possible to prevent an unauthorized overwrite from the DMA 13 to the kernel area 110 and to ensure the integrity of the operating kernel.

  FIG. 5 shows the second method. In general, a computer employs virtual storage as a memory management method. The address of the memory 11 viewed from the CPU 12 is a virtual address and is different from the physical address (real address) of the memory 11. The memory management unit 14 holds the correspondence between virtual addresses and physical addresses as a conversion table. When the user application is activated or terminated, the CPU 12 reconfigures the conversion table using the kernel function.

  In this embodiment, two types of conversion tables for kernel and user application are used as conversion tables. In the user application conversion table, a physical address other than the kernel area 110 is assigned to a virtual address corresponding to the kernel area 110 instead of the physical address of the kernel area 110. When a request to access the memory 11 is generated, the CPU 12 determines whether the request is from the kernel or a user application, and stores the virtual address of the access destination memory 11 together with information for identifying the request source. 14 to output.

  The memory management unit 14 converts the virtual address output from the CPU 12 into a physical address based on the conversion table. When the request source is a kernel, the memory management unit 14 converts the virtual address into a physical address by using a conversion table for the kernel. In the conversion table for the kernel, the kernel can access the kernel area 110. When the request source is a user application, the memory management unit 14 converts the virtual address into a physical address using the conversion table for the user application. Specifically:

  When the virtual address output from the CPU 12 does not correspond to the physical address of the kernel area 110, that is, when the CPU 12 tries to access an area other than the kernel area 110 (access 52 in FIG. 5), the physical address of the area is the memory management. The data is output from the unit 14 to the memory 11. When the virtual address output from the CPU 12 corresponds to the physical address of the kernel area 110, that is, when the CPU 12 is trying to access the kernel area 110 (access 53 in FIG. 5), the kernel area 110 that the CPU 12 was trying to access The physical address of an area different from that is output from the memory management unit 14 to the memory 11. Therefore, even if the user application tries to write to the kernel area 110, it writes to an area other than the kernel area 110. In this way, it is possible to prevent the kernel area 110 from being illegally overwritten by the user application and to ensure the integrity of the running kernel.

  The third method is to prevent the kernel area 110 from being overwritten illegally by preventing a kernel buffer overflow attack. In the kernel buffer overflow attack, a malicious execution program is stored in the data area of the kernel area 110, and this execution program is activated on the data area to execute malicious processing. In addition, this processing writes to the program area of the kernel area 110, and the kernel program is falsified.

  Therefore, the CPU 12 performs a setting that disables execution authority of the data area of the kernel area 110 according to the kernel program. Therefore, even when a malicious execution program is stored in the data area of the kernel area 110 by the user application, the execution of the execution program is not permitted. Therefore, the kernel area 110 is prevented from being overwritten and is in operation. Can guarantee the integrity of the kernel.

(4) A digital signature by the complete kernel for the result of the complete verification application confirming the state of the file FIG. 6 shows the processing when the verification application confirms the state of the system file in the HDD 10 . The verification application 41 belonging to the user space 40 is a user application activated by the processing shown in FIG. Since the verification application 41 is activated by the processing of the activation control unit 31 and the verification unit 32 whose integrity is guaranteed, the integrity of the verification application 41 is guaranteed.

  The hash interface 33 belonging to the kernel space 30 is a character-based interface for inputting / outputting data between the kernel and the user application. The signature unit 34 belonging to the kernel space 30 holds a secret key Ks, and encrypts with this secret key Ks to generate an electronic signature.

  The verification application 41 verifies the system file in the HDD 10 as follows. First, the verification application 41 reads a system file from the HDD 10 into the user area 111 of the memory 11 and calculates a hash value of the system file. This hash value represents the state of the system file. When the system file is falsified, the hash value changes. The verification application 41 holds in the user area 111 a hash value list in which information (file name or the like) for identifying a system file and a calculated hash value are associated and listed. Further, the verification application 41 further calculates a hash value from the entire hash value list (step S200).

  The verification application 41 outputs the hash value of the hash value list to the hash interface 33 and requests a signature (step S210). The hash interface 33 passes the hash value to the signature unit 34 (step S220).

  The signature unit 34 encrypts the received hash value with the secret key Ks and generates an electronic signature. The signature unit 34 passes the generated electronic signature to the hash interface 33 (step S230). The hash interface 33 outputs the electronic signature to the verification application 41 (step S240). The verification application 41 adds an electronic signature to the stored hash value list and stores it in the HDD 10 (step S250).

  Based on the hash value list stored in the HDD 10 as described above, it is possible to verify whether or not the system file on the HDD 10 has been falsified. That is, the hash value in the hash value list acquired at the first timing for the predetermined system file is compared with the hash value in the hash value list acquired at the second timing, and both hash values are equal. If not, it can detect that the system file has been tampered with. If both hash values match, it can be confirmed that the system file has not been tampered with.

  On the other hand, it is possible to verify whether or not the hash value list has been tampered with by verifying the electronic signature added to the hash value list. That is, the hash value obtained by decrypting the digital signature added to the hash value list with the public key corresponding to the secret key Ks is compared with the hash value calculated from the entire hash value list, and both hash values are If they do not match, it can be detected that the hash value list has been tampered with. If both hash values match, it can be confirmed that the hash value list has not been tampered with.

  Since the above-mentioned electronic signature is generated by a kernel whose integrity is guaranteed, an electronic signature whose integrity is guaranteed is added to the result of the verification application 41 confirming the state of the system file. Can do.

  Verification of the hash value list stored in the HDD 10 and verification of the electronic signature added to the hash value list can be performed by a remote terminal (file verification device). That is, the CPU 12 executes a process of reading a hash value list from the HDD 10 and transmitting it to the remote terminal by a user application that performs communication. The remote terminal receives the hash value list and stores it in its own HDD. Subsequently, the remote terminal reads the hash value list from the HDD, verifies the hash value list described above, and verifies the electronic signature added to the hash value list. Note that the remote terminal holds a correct hash value list to be compared with the acquired hash value list in advance, and compares the hash value in the acquired hash value list with the correct hash value to thereby store the correct hash value list on the HDD 10. Verify whether the system file has been tampered with.

  As described above, according to this embodiment, the kernel is activated when it is confirmed that the kernel has not been tampered with, and access from the user application to the kernel area 110 of the memory 11 is prohibited while the kernel is running. As a result, the integrity of the booting and running kernel is guaranteed. In addition, since it is confirmed that the user application has not been tampered with by the kernel whose integrity is guaranteed, the integrity of the user application at the time of activation is guaranteed. Therefore, it is possible to start a user application whose integrity is guaranteed from a kernel whose integrity is guaranteed. In addition, by starting the verification application whose integrity is guaranteed, the complete verification application can check the state of the file.

  As described above, the complete verification application can check the state of the file, but the hash value list that is the output result of the verification application may be falsified on the HDD 10. However, in this embodiment, since an electronic signature by a kernel whose integrity is guaranteed is added to the hash value list, it is possible to detect falsification of the hash value list on the HDD 10 based on the electronic signature. . Therefore, the reliability of the hash value list can be improved.

  The present embodiment can be applied not only to a server such as a public server but also to a mobile phone or the like. For example, a telephone company can remotely verify the state of a mobile phone owned by a user, or a service provider can remotely verify the state of a home appliance such as a set-top box lent to the user.

  As described above, the embodiments of the present invention have been described in detail with reference to the drawings. However, the specific configuration is not limited to the above-described embodiments, and includes design changes and the like without departing from the gist of the present invention. .

  DESCRIPTION OF SYMBOLS 10 ... HDD (program storage means, file storage means), 11 ... Memory, 12 ... CPU, 13 ... DMA, 14 ... Memory management part (prohibition means), 15 ... Kernel Activation control unit (kernel verification means), 20 ... bus, 31 ... activation control unit, 32 ... verification unit, 33 ... hash interface, 34 ... signature unit, 110 ... kernel area 111 user area

Claims (2)

Program storage means for storing OS kernel and user application programs;
A memory having a kernel area in which the kernel program is stored; and a user area in which the user application program is stored;
Kernel verification means for verifying the integrity of the kernel at the time of booting the kernel;
A CPU that executes processing according to a program stored in the memory;
Prohibiting means for prohibiting data writing from the user application to the kernel area;
File storage means for storing system files;
The CPU comprises:
When the kernel verification means can confirm that the kernel has not been tampered with, a process of starting the kernel by reading the kernel program from the program storage means into the kernel area; and
When the kernel verifies the integrity of the user application when the user application is started and confirms that the user application has not been tampered with, the user application program is transferred from the program storage unit to the user area. Processing to load the application and start the user application;
Processing for calculating a hash value of the system file by the user application;
A process of applying an electronic signature to the hash value by the kernel;
Processing for verifying the integrity of the system file based on the hash value by the user application ;
Processing for verifying the integrity of the hash value based on the electronic signature by the user application;
An information processing apparatus characterized by executing A file verification system comprising an information processing device and a file verification device,
The information processing apparatus includes:
Program storage means for storing OS kernel and user application programs;
A memory having a kernel area in which the kernel program is stored; and a user area in which the user application program is stored;
Kernel verification means for verifying the integrity of the kernel at the time of booting the kernel;
A CPU that executes processing according to a program stored in the memory;
Prohibiting means for prohibiting data writing from the user application to the kernel area;
File storage means for storing system files ;
The CPU comprises:
When the kernel verification means can confirm that the kernel has not been tampered with, a process of starting the kernel by reading the kernel program from the program storage means into the kernel area; and
When the kernel verifies the integrity of the user application when the user application is started and confirms that the user application has not been tampered with, the user application program is transferred from the program storage unit to the user area. Processing to load the application and start the user application;
Processing for calculating a hash value of the system file by the user application;
A process of applying an electronic signature to the hash value by the kernel;
A process of transmitting the hash value and the electronic signature to the file verification device by the user application;
Run
The file verification device
Receiving means for receiving the hash value and the electronic signature from the information processing apparatus;
First verification means for verifying the integrity of the system file based on the hash value;
Second verification means for verifying the integrity of the hash value based on the electronic signature;
A file verification system comprising:

Images