JP7304430B2 - Information processing system, inter-program key sharing method, and inter-program key sharing program - Google Patents

Description

Import by reference

This application claims priority from Japanese Patent Application No. 2019-222400 filed on December 9, 2019, the content of which is incorporated into the present application by reference.

The present invention relates to technology for preventing malicious program activity.

With the spread of mobile terminals and the sophistication of web services, the types of services are diversifying. Especially in recent years, services such as mobile payment, in which payments and remittances that have conventionally been performed via dedicated terminals at ATMs and tellers are executed on mobile terminals, are showing signs of popularity.

When using such a service, it is common to install dedicated software (hereinafter also referred to as a "program") and use the service via that program.

Also, user authentication (or terminal authentication) must be performed when using a service, and at this time, secret information possessed only by the user (or terminal) is used. Such authentication processing is desirably performed within an area on a SIM (Subscriber Identity Module) chip, but as described above, in most cases confidential information is handled on a program. This is because the SIM chip has a low memory capacity and processing power for installing the service program.

On the other hand, from the perspective of mobile terminal security, the reality is that a certain percentage of mobile terminals are infected with malicious software (hereinafter referred to as "malware"), and the existence of malware specialized in financial services has also been confirmed. ing. In particular, there have been reports of the existence of malware that extracts credit card numbers by reading data placed in memory, so it is necessary to protect data placed in memory during program execution.

As a countermeasure against the above problems, there is a method of encrypting and storing data on the memory. For example, Patent Literature 1 discloses a technique of performing encryption when data is stored in memory without requiring special hardware support such as a CPU or memory mechanism. In this technology, a program that performs encryption processing generates and manages keys used for encryption (hereinafter referred to as "keys") in a CPU.

JP 2019-074913 A

Bui, T., Rao, S.P., Antikainen, M., Bojan, V.M., Aura, T.: Man-in-the-machine: Exploiting ill-secured communication inside the computer. In: 27th USENIX Security Symposium. pp. 1511 -1525. USENIX Association, Baltimore, MD (2018)

As a way to safely exchange data against malware between multiple programs that are installed in advance or installed later as needed, encrypting data in memory using the method described above There is a way to exchange the converted one between programs. This method requires that the programs share the key used to encrypt the data in memory.

Also, as a method of exchanging data between a plurality of programs, there is a method of creating a shared area on a memory that can be accessed by a plurality of programs and exchanging data via this shared area. Generally, when creating a shared area, an identifier associated with the shared area is set. A program that uses the shared area accesses the shared area using the identifier associated with the shared area, and acquires or writes values in the shared area. In order to exchange data using a shared area between a plurality of programs, it is necessary to share an identifier associated with the shared area among the programs.

As a key sharing method between multiple programs, consider a method of exchanging keys via the above-mentioned shared area. Non-Patent Document 1 reports that if an attacker can access a shared area, there is a risk that the attacker may obtain data on the shared area. When a shared area is used for key sharing between multiple programs, there is a risk that if malware acquires the key used to encrypt data on the memory stored in the shared area, the encryption of the data on the memory will be invalidated. .

SUMMARY OF THE INVENTION The present invention has been made in view of the circumstances described above, and provides a technique for safely sharing a key between two programs.

In order to achieve the above object, an information processing system according to one aspect includes:
An information processing system comprising a main memory storing data and programs, and a processor connected to the main memory and executing the programs,
an OS (operating system) for allocating resources including processors and main storage devices to programs to be executed based on predetermined allocation criteria;
comprising a first key sharing program and a second key sharing program for sharing a key and executing processing;
The processor runs an OS and
setting a shared area that can be shared for processing by the first key sharing program and the second key sharing program;
Allocating resources for the first key agreement program;
Allocating resources for a second key agreement program;
By executing the OS and executing the first key sharing program, the processor
Repeating the generation of random number data that can identify the random number for the second key sharing program to generate the second key, and the storage of the random number data in the shared area,
By executing the OS and executing the second key sharing program, the processor
Repeatedly obtaining random number data stored in the shared area,
generating a second key based on the obtained plurality of random number data;
generating key generation information capable of identifying a plurality of obtained random number data used to generate the second key;
Store the key generation information in the shared area,
By executing the OS and executing the first key sharing program, the processor
The first key is generated based on the key generation information stored in the shared area.
The details of at least one implementation of the subject matter disclosed in this specification are set forth in the accompanying drawings and the description below. Other features, aspects, and advantages of the disclosed subject matter will become apparent from the following disclosure, drawings, and claims.

According to the present invention, a key can be securely shared between two programs.

1 is an example of an overall configuration diagram of a network system according to an embodiment; FIG. 1 is an example of a configuration diagram of a terminal according to an embodiment; FIG. 1 is an example of a functional configuration diagram of a terminal according to an embodiment; FIG. FIG. 3 is an example of a functional configuration diagram realized by a first key sharing program and a second key sharing program according to one embodiment; FIG. 10 is an example of a functional configuration diagram during execution of a first key sharing program according to one embodiment; 6 is an example of a flowchart of random number data generation processing according to one embodiment. FIG. 10 is an example of a functional configuration diagram during execution of a second key sharing program according to one embodiment; 6 is an example of a flowchart of random number data acquisition processing according to one embodiment. FIG. 4 is an example of a sequence diagram of key sharing processing between a first key sharing program and a second key sharing program according to one embodiment; FIG. 11 is an example of a sequence diagram of key sharing processing according to the first modified example; FIG. 10 is an example of a sequence diagram showing an example of key sharing processing when there is malware impersonating a second key sharing program, according to an embodiment; FIG. 10 is an example of a sequence diagram showing an example of key sharing processing when there is malware impersonating the first key sharing program, according to one embodiment; FIG. 11 is an example of a sequence diagram of key sharing processing according to a second modified example; FIG. 11 is an example of a sequence diagram of key sharing processing according to a third modified example; FIG. 3 is an example of a functional configuration diagram realized by a first key sharing program and a second key sharing program according to one embodiment;

An embodiment will be described. It should be noted that the embodiments described below do not limit the invention according to the scope of claims, and that all of the elements described in the embodiments and their combinations are essential to the solution of the invention. is not limited.

In the following description, the information may be described using the expression of "AAA table", but the information may be expressed in any data structure. That is, the "AAA table" can be called "AAA information" to indicate that the information is independent of the data structure.

Further, in the following description, the processing may be described with the "program" as the subject of the operation, but the program is executed by a processor (for example, a CPU (Central Processing Unit)) to perform a predetermined process. A processor (or a device or system having the processor) may be the subject of the operation of the processing because it is performed using a storage unit (e.g. memory) and/or an interface device (e.g. communication port) as appropriate. A processor may also include hardware circuitry that performs some or all of the processing. A program may be installed on a device, such as a computer, from a program source. The program source may be, for example, a program distribution server or a computer-readable storage medium. Also, in the following description, two or more programs may be implemented as one program, and one program may be implemented as two or more programs.

First, the outline of this embodiment will be described.

In the present embodiment, the programs securely share the key without modifying the OS (Operating System) of the terminal as an example of the information processing system. Therefore, in this embodiment, for example, the following OS functions are used.

The OS (strictly speaking, the processor that executes the OS) allocates resources to each program according to predetermined allocation criteria using information in the terminal. In general, the order in which resources are allocated to programs by the OS is not constant, so if multiple programs repeatedly attempt to access the same resource at the same time, the order in which the programs access the resources is not constant.

A program (strictly speaking, the processor that executes the program) calls an API (Application Programming Interface) prepared by the OS, and the OS creates an area in memory that can be accessed by multiple programs ("shared area"). ).

In this embodiment, the key is shared between the programs (between the first key sharing program and the second key sharing program) by, for example, the following method.

The first key sharing program (strictly speaking, the processor that executes the first key sharing program) repeats the process of generating a random number and index information and writing a set of these as random number data in the shared area. Also, the first key sharing program records the random number data written in the shared area in the random number data table.

On the other hand, the second key sharing program (strictly speaking, the processor that executes the second key sharing program) writes the random number data in the shared area while the first key sharing program repeatedly writes the random number data in the shared area. Repeat data acquisition. The second key sharing program generates a key using random numbers in the random number data obtained from the shared area. Also, the second key sharing program writes the index numbers of all the random number data used for key generation to the shared area as key generation information.

The first key sharing program obtains the key generation information stored in the shared area, and based on this key generation information, obtains the random number used by the second key sharing program to generate the key from the random number data table, Generate a key using the obtained random number.

Through this series of processes, the first key sharing program and the second key sharing program can generate keys having the same value, that is, share the keys.

According to this embodiment, the timing at which each program running on the OS can access the shared area is determined as needed by the OS based on a predetermined allocation criterion. For this reason, as described above, by repeatedly storing and acquiring random number data for key generation via a shared area between programs, even if malware can access the shared area, the second key It is difficult for malware to acquire all of the random number data that the sharing program uses for key generation, and it is also difficult for malware to write all of the random number data that the second key sharing program acquires.

As a result, it is difficult for the malware to obtain the key to be used between the first key sharing program and the second key sharing program. reduce the risk of

The present embodiment will be described in detail below with reference to the drawings.

FIG. 1 is an overall configuration diagram of a network system according to one embodiment.

The network system 100 has an information processing device (terminal) 102 as an example of an information processing system, a program distribution server 103 , an authentication server 111 and a program server 112 . Terminal 102 is used by user 101 . The authentication server 111 and program server 112 provide predetermined services by the service provider 110 .

The terminal 102 downloads a program for using the service provided by the service provider 110 from the program distribution server 103 according to the operation of the user 101 . The terminal 102 installs the program downloaded by the operation of the user 101 . After installing the program, the user 101 can access the authentication server 111 from the terminal 102 and perform user registration. After completing user registration, the user 101 can use the service of the service provider 110 using the terminal 102 .

When the terminal 102 receives an instruction to use a service from the user 101 , the terminal 102 receives user authentication (or device authentication) from the authentication server 111 and then allows the service to be used through the program server 112 .

FIG. 2 is a configuration diagram of a terminal according to one embodiment.

The terminal 102 includes a sensor 202 , a memory 205 as an example of a main storage device, a CPU 206 as an example of a processor, a network IF (interface) 208 and a storage 210 .

The sensor 202 is, for example, a camera, a microphone, or the like, and senses biometric information (for example, fingerprint information) 201 of the user 101 to generate sensor data 203 .

The memory 205 is, for example, a RAM (RANDOM ACCESS MEMORY), and stores programs executed by the CPU 206 and necessary information.

The network IF 208 is, for example, an interface such as a wired LAN card or a wireless LAN card, and communicates with other devices (eg, program distribution server 103, authentication server 111, program server 112) via a communication path.

The CPU 206 executes various processes according to programs stored in the memory 205 and/or storage 210 .

The storage 210 is, for example, a hard disk or flash memory, and stores programs executed by the CPU 206 and data used by the CPU 206 . In this embodiment, the storage 210 stores, for example, a sensor program 211 that acquires sensor data 203 of the biometric information 201 via the sensor 202 and an authentication program 212 that transmits and receives data to and from the authentication server 111 .

Note that the terminal 102 may contain malware 204 . Although the malware 204 is shown schematically in FIG. 2, it is actually stored in the memory 205 or the storage 210, for example.

Here, processing when the terminal 102 uses user authentication by the authentication server 111 will be described.

The CPU 206 of the terminal 102 acquires the sensor data 203 generated by sensing the biological information 201 of the user 101 from the sensor 202 by executing the sensor program 211 and stores the sensor data 203 in the memory 205 . Next, by executing the authentication program 212 , the CPU 206 performs appropriate processing on the sensor data 203 to generate communication data 207 and transmits the communication data 207 to the authentication server 311 via the network IF 208 . As a result, user authentication is executed in the authentication server 311 .

FIG. 3 is a functional configuration diagram of a terminal according to one embodiment.

In the terminal shown in FIG. 2, the terminal 102 allows the sensor program 211 and the authentication program 212 to safely exchange the sensor data 203 between the sensor program 211 and the authentication program 212. It is a terminal designed to encrypt data.

In the following description, the programs that perform processing for executing key sharing for encryption between the sensor program 211 and the authentication program 212 are the first key sharing program 305 and the second key sharing program 306, which will be described later. will be described.

One or both of the first key sharing program 305 and the second key sharing program 306 may be programs that are not included in the sensor program 211 or the authentication program 212 . A configuration in this case will be described later.

Terminal 102 comprises network IF 208 , sensor 202 , entropy generator 302 , storage 210 , CPU 206 and memory 205 . These functional configurations are connected to each other by a data bus and can exchange data via the memory 205 .

The entropy generator 302 produces a value with entropy (referred to as an "entropy source"). Here, a value (referred to as “seed”) for generating pseudo-random numbers is generally generated from an entropy source. If the size of the generated entropy source is not sufficient, a seed is generated based on the iteratively generated entropy source.
Note that the entropy generator 302 may be provided as a function by the OS 304, or may be provided as a function by a program.

The CPU 206 holds a plurality of general-purpose registers 303 for storing data handled in arithmetic processing.

The storage 210 stores program execution files and setting files. In this embodiment, storage 210 stores first key sharing program 305 and second key sharing program 306 . The first key sharing program 305 and the second key sharing program 306 correspond to inter-program key sharing programs.

Note that the first key sharing program 305 and the second key sharing program 306 may be stored in advance in the storage 210, or if necessary, from a non-temporary storage device of another device via a network, or It may be stored in the storage 210 from a non-temporary storage medium.

A program called an OS 304 resides in the memory 205 . The OS 304, when executed by the CPU 206, mediates data between hardware and programs, and manages the execution authority and resources of a plurality of programs.

A user program is executed by the CPU 206 under limited authority called user authority under the control of the OS 304 . On the other hand, processing related to resource management of the OS 304 is executed by the CPU 206 under stronger authority. Here, the first key sharing program 305, the second key sharing program 306, and the malware 204 correspond to user programs.

The memory 205 has a kernel space 310 used by the central processing of the OS 304 and a user space 320 used by user programs.

When user programs such as the first key sharing program 305 and the second key sharing program 306 stored in the storage 210 are executed, they are deployed in the user space 320 .

The first key-sharing program 321 and the second key-sharing program 324 developed on the user space 320 are memory usage areas on the user space 320 allocated by the OS 304 for each program (for example, memory areas allocated to the first key-sharing program 321). Processing is executed by the CPU 206 using the first key sharing program allocation area 322 and the second key sharing program allocation area 325 allocated to the second key sharing program 324 .

The use area of the memory 205 allocated to the user program may be dynamically secured during execution of the user program, or dynamically during execution of the user program (for example, alloc function, etc.).

In general, the OS 304 allocates a different area for each program on the user space 320 as a memory utilization area for the program. The shared area 323 can be secured by specifying this to the OS 304 at the start of program execution or during execution.

As an example of a method for creating the shared area 323 for a plurality of programs, use of the inter-process communication technique (referred to as "IPC") of Non-Patent Document 1 can be mentioned. IPC is a mechanism prepared by the OS 304 to exchange data between processes. IPCs include pipes, message queues, shared memory, sockets, and the like. In this embodiment, the first key sharing program 321 and the second key sharing program 324 are configured to secure a shared area 323 in the user space 320 of the memory 205 . The shared area 323 may be secured by the first key sharing program 321 or by the second key sharing program 324 . In this embodiment, for the sake of convenience, it is assumed that the first key sharing program 321 secures the shared area.

When executing a plurality of programs, the process management function of the OS 304 allocates hardware resources such as the CPU 206 and memory 205 to one of the programs, and switches the allocation of the hardware resources as appropriate (referred to as "interrupt"). )I do. For example, when an interrupt by the second key sharing program 324 occurs during the execution of the first key sharing program 321, the CPU 206 executing the OS 304 transfers the information in the general register 303 of the first key sharing program 321 to the kernel space 310. Save and store in the first key sharing program save area 311 . Thereafter, CPU 206 allocates the hardware resource to second key sharing program 324 to which the hardware resource is to be allocated next, and starts executing second key sharing program 324 . After the execution of the second key sharing program 324 ends, the CPU 206 restores the data in the first key sharing program save area 311 to the general-purpose register 303 and restarts the processing of the first key sharing program 321 .

The CPU 206 executing the OS 304 determines a program to allocate hardware resources based on, for example, time information such as a cycle counter and execution priority information for each program, and performs interrupt processing as necessary. Therefore, when there are multiple programs to be executed, the order in which hardware resources are allocated to the multiple programs is not necessarily a fixed order.

The first key sharing program 321 of this embodiment sequentially generates and shares random number data including random numbers and index information according to a predetermined rule (for example, between a request to start delivery of random number data and a request to end delivery). Store in area 323 . Here, the random number data is stored in the shared area 323 at the timing when the resource is allocated to the first key sharing program 321 by the OS 304 . At least part of the random number data stored in the shared area 323 in this manner is acquired by the second key sharing program 324 . Also, the first key sharing program 321 acquires the key generation information generated by the second key sharing program 324 from the shared area 323, and generates the first key based on the key generation information.

On the other hand, the second key sharing program 324 obtains the random number data stored by the first key sharing program 321 via the shared area 323, generates a second key based on the obtained random number data, is generated, and stored in the shared area 323 . Here, the random number data is acquired from the shared area 323 at the timing when the resource is allocated to the second key sharing program 324 by the OS 304 .

In this embodiment, the first key generated by the first key sharing program 321 and the second key generated by the second key sharing program 324 have the same value when there is no influence of the malware 204 or the like. That is, the first key sharing program 321 and the second key sharing program 324 can share a key. The details of key sharing will be described later.

Next, a functional configuration configured by the CPU 206 executing the first key sharing program 321 and the second key sharing program 324 will be described in detail.

FIG. 4 is a functional configuration diagram realized by a first key sharing program and a second key sharing program according to one embodiment.

By executing the first key sharing program 321 by the CPU 206, a random number data generation/distribution unit 400, a key generation information acquisition/key generation unit 410, and a first data secrecy processing unit 420 are configured.

The random number data generation/distribution unit 400 generates random number data and stores it in the shared area 323 so that the random number data is distributed to the second key sharing program 324 via the shared area 323 .

The random number data generation/distribution unit 400 includes a random number data generation unit 401 and a random number data distribution unit 404 .

The random number data generator 401 generates random number data including random numbers and index information. The random number data generator 401 includes a random number generator 402 and an index generator 403 . The random number generator 402 generates random numbers using the seed generated by the entropy source generated by the entropy generator.

At this time, the data size of one random number generated by the random number generation unit 402 may be smaller than the size of random numbers required to generate the first and second keys. The index generation unit 403 generates index information that identifies the generated random numbers. The index generator 403 may use, for example, the output of a counter as the index information.

The random number data distribution unit 404 stores the random number data generated by the random number data generation unit 401 in the shared area 323 .

The key generation information acquisition/key generation unit 410 acquires the key generation information stored in the shared area 323 by the second key sharing program 324 and generates the first key based on the key generation information. The key generation information acquisition/key generation unit 410 includes a key generation information acquisition unit 411 and a first key generation unit 412 . Key generation information acquisition unit 411 acquires key generation information stored in second key sharing program 324 from shared area 323 . The first key generation unit 412 generates the first key using the key generation information acquired by the key generation information acquisition unit 411 .

The first data concealment processing unit 420 performs predetermined processing while concealing data stored in the memory 205 using the generated first key. For example, the first data encryption processing unit 420 performs encryption processing to encrypt the sensor data 203 with the first key, and stores the encrypted data in the memory 205 . As the encryption processing of the first data encryption processing unit 420, for example, the method of Patent Document 1 may be used.

The second key sharing program 324 includes a random number data acquisition/key generation unit 430 and a second data secrecy processing unit 440 .

Random number data acquisition/key generation unit 430 acquires random number data from shared area 323 and generates a second key. The random number data acquisition/key generation unit 430 includes a random number data acquisition unit 431 , a second key generation unit 432 , and a key generation information distribution unit 433 . The random number data acquisition unit 431 acquires random number data from the shared area 323 . The second key generation unit 432 generates a second key based on the random number data acquired by the random number data acquisition unit 431 . The second key generation unit 432 may generate the second key based on the plurality of random number data acquired by the random number data acquisition unit 431. For example, one or more random number data is selected from among the plurality of random number data. and the selected random number data may be used to generate the second key. The key generation information distribution unit 433 stores index information of all random number data used for key generation in the shared area 323 as key generation information.

The second data encryption processing unit 440 performs predetermined processing while encrypting the data stored in the memory 205 using the second key. For example, the second data secrecy processing unit 420 decrypts the encrypted sensor data 203 stored in the memory 205 using the second key, and uses the decrypted sensor data 203 to perform authentication processing, for example. As the encryption processing of the second data encryption processing unit 440, for example, the method of Patent Document 1 may be used.
Also, when sending data from the second data anonymization processing unit 440 to the first data anonymization processing unit 420, the above-described processing may be performed in the same manner.

Next, the configuration of terminal 102 when first key sharing program 305 is executed will be described.

FIG. 5 is a functional configuration diagram showing a state during execution of the first key sharing program according to one embodiment. In addition, the same reference numerals are given to the same parts as the elements shown in FIG. 3, and overlapping explanations are omitted.

The first key sharing program 305 is developed as the first key sharing program 321 on the user space 320 of the memory 205 . The CPU 206 executes the first key sharing program 321 while storing program variables and data being processed in the general-purpose register 303 and the first key sharing program allocation area 322 on the memory 205 .

The general-purpose register 303 stores a seed 501, a random number data table 502, a first key 503, key generation information 504, index information 505, and a random number 506 according to the status of processing.

Also, the shared area 323 stores random number data 524 and key generation information 525 used in processing.

In this way, if another program (including the malware 204) interrupts while the first key sharing program 321 is running, the function of the OS 304 causes the CPU 206 to change the data on the general-purpose register 303 (seed 501 , random number data table 502 , first key 503 , key generation information 504 , index information 505 , random number 506 , etc.) are stored in first key sharing program save area 311 of kernel space 310 . In this case, the program to be executed by the interrupt cannot access the data in the first key sharing program save area 311 . Therefore, the malware 204 cannot obtain the seed 501, the random number data table 502, the first key 503, the key generation information 504, the index information 505, the random number 506, etc. from the first key sharing program save area 311, so information leaks. can be prevented.

In the example of FIG. 5, the seed 501, random number data table 502, first key 503, key generation information 504, index information 505, and random number 506 are stored in the general-purpose register 303, but they are stored in the memory 205. You may do so.

Next, random number data generation processing performed by the CPU 206 executing the first key sharing program 321 will be described. This random number data generation process is executed by the random number data generation/distribution unit 400 shown in FIG.

FIG. 6 is a flowchart of random number data generation processing according to one embodiment.

First, the random number data generation/distribution unit 400 secures a shared area 323 shared with the second key sharing program 324 in the user space 320 of the memory 205 (step 601).

Next, the random number data generation/distribution unit 400 checks whether or not a request to start distribution of random number data (distribution start request) has been received from the second key sharing program 324 (step 602). (Step 602: No) waits until a delivery start request is received.

On the other hand, when the delivery start request is received (step 602: Yes), the random number data generation/delivery unit 400 generates a random number by the random number generation unit 402, and the index information indicating the generated random number by the index generation unit 403. is generated (step 603).

Next, random number data generation/distribution unit 400 writes random number data 524 including the generated random number and corresponding index information to shared area 323 (step 604). If there is already written random number data 524 in the shared area 323 , the random number data generation/distribution unit 400 overwrites this random number data with new random number data 524 . As a result, the latest random number data 524 exists in the shared area 323 .

Next, the random number data generation/distribution unit 400 adds the new random number data 524 as an entry to the random number data table 502 (step 605). As a result, the random number data table 502 stores an entry corresponding to each random number data 524 generated by the random number data generation/distribution unit 400 .

Next, the random number data generation/delivery unit 400 checks whether or not a request to end delivery of random number data (delivery end request) has been received from the second key sharing program 324 (step 606). As a result, if the delivery end request has not been received (step 606: No), the random number data generation/delivery unit 400 advances the process to step 603 because it is still necessary to generate random number data.

On the other hand, when the delivery end request is received (step S606: Yes), the random number data generation/delivery unit 400 ends the process.

If the second key sharing program 324 secures the shared area 323 of the memory 205 between the first key sharing program 321 and the second key sharing program 324, step 601 need not be performed.

Next, the configuration of terminal 102 when executing second key sharing program 306 will be described.

FIG. 7 is a functional configuration diagram showing a state during execution of the second key sharing program according to one embodiment. In addition, the same reference numerals are given to the same parts as the elements shown in FIG. 3, and overlapping explanations are omitted.

The second key sharing program 306 is developed as a second key sharing program 324 on the user space 320 of the memory 205 . The CPU 206 executes the second key sharing program 324 while storing program variables and data being processed in the general-purpose register 303 and the second key sharing program allocation area 325 on the memory 205 .

The general-purpose register 303 stores a random number data pool 711, a second key 713, and key generation information 714 according to the processing status. A random number data pool 711 stores a plurality of random number data 712 acquired from the shared area 323 .

In this way, if another program (including the malware 204) interrupts while the second key sharing program 324 is running, the function of the OS 304 causes the CPU 206 to change the data on the general-purpose register 303 (For example, the random number data 712 of the random number data pool 711, the second key 713, the key generation information 714, etc.) are stored in the second key sharing program save area 312 of the kernel space 310. FIG. In this case, the program to be executed by the interrupt cannot access the data in the second key sharing program save area 312 . Therefore, since the malware 204 cannot acquire the random number data 712, the second key 713, the key generation information 714, etc. of the random number data pool 711 from the second key sharing program save area 312, information leakage can be prevented. .

Next, random number data acquisition processing performed by the CPU 206 executing the second key sharing program 324 will be described. This random number data acquisition process is executed by the random number data acquisition unit 431 shown in FIG.

FIG. 8 is a flowchart of random number data acquisition processing according to one embodiment.

First, the random number data acquisition unit 431 transmits a request to start delivering random number data to the first key sharing program 321 (step 801).

Next, the random number data acquisition unit 431 acquires the random number data 524 in the shared area 323 and additionally stores it as the random number data 712 in the random number data pool 711 (step 802). Here, the timing at which the random number data acquisition unit 431 can acquire the random number data 524 from the shared area 323 is the timing at which the resource is allocated by the OS 304, and the acquired random number data 524 is stored in the shared area 323 at that time. random number data 524. Therefore, it is not always possible to obtain all of the random number data 524 sequentially stored in the shared area 323 by the first key sharing program 321 .

Next, the random number data acquisition unit 431 determines whether or not the number of random number data 712 in the random number data pool 711, that is, the usable random number size is sufficient for key generation (step 803). For example, if the random number size of one piece of random number data 712 is smaller than the size required for key generation, it is determined whether or not a plurality of pieces of random number data have been acquired.

As a result, if the size of the random number is not sufficient for key generation (step 803: No), the random number data acquiring unit 431 proceeds to step 802 and acquires further random number data.

On the other hand, if the size of the random number is sufficient for key generation (step 803: Yes), the random number data acquisition unit 431 transmits a delivery end request to the first key sharing program 321 (step 804), End the process.

According to this random number data acquisition process, the random numbers required for key generation in the second key sharing program 324 can be appropriately acquired.

Note that when the second key sharing program 324 secures the shared area 323 of the memory 205 shared by the first key sharing program 321 and the second key sharing program 324, before performing step 801, A process similar to that shown in step 601 may be performed.

Next, key sharing processing for sharing a key between the first key sharing program 321 and the second key sharing program 324 will be described.

FIG. 9 is a sequence diagram of key sharing processing between the first key sharing program and the second key sharing program according to one embodiment.

First, the second key sharing program 324 transmits a delivery start request for the random number data 524 to the first key sharing program 321 (step S11).

Upon receiving the delivery start request, the first key sharing program 321 repeatedly writes the random number data to the shared area 323 (step S12).

Here, in FIG. 9, the random numbers are represented by r ₀ , r ₁ , . , index number).

In the example of FIG. 9, the first key sharing program 321 stores random number data (r ₀ , 0) in the shared area 323, stores random number data (r ₁ , 1) in the shared area 323, stores random number data (r ₂ , 2) are stored in the shared area 323 , and the process of generating random number data and storing it in the shared area 323 is repeatedly executed until a distribution end request is received from the second key sharing program 324 . The first key sharing program 321 also adds each piece of random number data to the random number data table 502 as an entry. The timing at which the first key sharing program 321 stores the random number data in the shared area 323 depends on the timing at which the OS 304 allocates resources to the first key sharing program 321 .

On the other hand, the second key sharing program 324 repeatedly executes the process of acquiring random number data from the shared area 323 (step S13).

Here, the timing at which the second key sharing program 324 acquires random number data from the shared area 323 depends on the timing at which the OS 304 allocates resources to the second key sharing program 324 . For this reason, _{for example} , as shown in FIG. , the random number data is not acquired from the shared area 323 by the second key sharing program 324, and the second key sharing program 324 cannot acquire the random number data (r ₁ , 1). It can also occur. Note that in this embodiment, the second key sharing program 324 does not need to acquire all of the random number data 524 stored by the first key sharing program 321 .

After that, the second key sharing program 324 sends a delivery end request to the first key sharing program 321 when the size of the random number data 712 in the random number data pool 711 becomes equal to or larger than the size sufficient to generate a key. (step S14: corresponding to step 804 in FIG. 8). As a result, the first key sharing program 321 terminates the random number data generation process.

Next, the second key sharing program 324 generates a second key 713 using all or part of the obtained random number data 712 . Any random number data 712 may be selected and used as long as the size required for key generation can be secured.

Further, the second key sharing program 324 writes the index number of the random number data 712 used to generate the second key 713 to the shared area 323 as the key generation information 525 (step S15). According to this key generation information 525, it is possible to specify which random number of random number data was used to generate the second key 713. FIG.

On the other hand, the first key sharing program 321 acquires the key generation information 525 from the shared area 323 (step S16).

Thereafter, the first key sharing program 321 obtains the random number used by the second key sharing program 324 to generate the second key 713 by referring to the random number data table 502 based on the key generation information 525. and generate the first key 503 using these random numbers. It should be noted that the method of generating the key from the random number is determined in advance as a method common to the first key sharing program 321 and the second key sharing program 324 .

According to the above process, the first key sharing program 321 and the second key sharing program 324 generate keys using the same random number, so the values of the first key 503 and the second key 713 match. It will happen. That is, the first key sharing program 321 and the second key sharing program 324 successfully share the key. At this time, the first key sharing program 321 may repeat acquisition of the key generation information 525 for a certain period of time. When the first key sharing program receives a plurality of key generation information 525 with different values, it can detect malware 204 impersonating the second key sharing program 324 .

In the above embodiment, the first key sharing program 321 may check whether or not the second key sharing program 324 has acquired the random number data 524 written in the shared area 323. For example, when the random number data 524 is not acquired by the second key sharing program 324, the storage of the next random number data is delayed or the cycle of storing the random number data is lengthened. may By doing so, the processing load on the CPU 205 can be reduced.

In the above-described embodiment, key sharing processing (first modified example) further performs key sharing confirmation processing for confirming whether or not the first key sharing program 321 and the second key sharing program 324 have successfully shared a key with each other. can be considered.

FIG. 10 is a sequence diagram of key sharing processing according to the first modification. Note that processing similar to the key sharing processing shown in FIG. 9 is given the same reference numerals, and redundant description is omitted.

In this key sharing process, the first key sharing program 321 and the second key sharing program 324 use a message authentication code (referred to as "MAC") to mutually confirm whether or not the key sharing has succeeded. there is

After generating the first key 503, the first key sharing program 321 calculates the MAC value using an arbitrary message m and the first key 503, and stores the used message m and the MAC value in the shared area 323. (step S17). Note that in FIG. 10, the MAC value calculated using the message m and the first key 503 is expressed as MAC(m, first key).

On the other hand, the second key sharing program 324 acquires the message m and the MAC value from the shared area 323 (step S18). Next, the second key sharing program 324 calculates the MAC value (MAC(m, second key)) from the message m and the second key 713, and obtains the MAC value (MAC(m, first key)) and It is confirmed whether or not the calculated MAC value (MAC(m, second key)) is equal. Here, when the MAC value (MAC(m, first key)) and the MAC value (MAC(m, second key)) are equal, the first key 503 and the second key 713 have the same value. It means that the key agreement is successful. Therefore, when the obtained MAC value (MAC(m, first key)) is equal to the calculated MAC value (MAC(m, second key)), the second key sharing program 324 successfully performs key sharing. A key sharing success signal indicating that it has been completed is transmitted to the first key sharing program 321 (step S19). The first key sharing program 321 can recognize that the key sharing with the second key sharing program 324 has been successful by receiving the key sharing success signal.

In the above example, the first key sharing program 321 generates the MAC value, and the second key sharing program 324 compares the MAC value generated by the first key sharing program 321 with the MAC value calculated by itself. For example, the second key sharing program 324 generates the MAC value, and the first key sharing program 321 generates the MAC value by the second key sharing program 324. Successful key sharing may be confirmed by comparing the MAC value with the MAC value calculated by itself.

Further, although the MAC value is stored in the shared area 323 used for key sharing, the shared area for sharing the MAC value may be an area separate from the shared area 323 .

Next, a key sharing process will be described in the case where the malware 204 impersonating the second key sharing program 324 exists in the terminal 102 in the above-described embodiment.

FIG. 11 is a sequence diagram illustrating an example of key sharing processing when malware 204 is present, according to one embodiment. Note that processing similar to the key sharing processing shown in FIG. 9 is given the same reference numerals, and redundant description is omitted.

Here, it is assumed that the malware 204 can wiretap (reference) the shared area 323 between the first key sharing program 321 and the second key sharing program 324 . It is assumed that the malware 204 attempts to generate the same key (first key, second key) shared by the first key sharing program 321 and the second key sharing program by eavesdropping.

The malware 204 can acquire random number data by referring to the shared area 323 (step S21).

Here, in the terminal 102, the OS 304 determines a program that can access resources based on information in the terminal 102 as needed. For this reason, when a plurality of programs repeat the process of issuing access requests to the same resource (here, the shared area 323) to the OS 304, the order in which the programs access the resource is always different. For this reason, when the first key sharing program 321 and the second key sharing program 324 repeatedly access the shared area 323, the malware 204 that can access the shared area 323 can access the shared area 323 like these programs. Even if accesses to the shared area 323 are repeated, the order of programs that can access the shared area 323 is determined as needed by the OS 304 .

Therefore, when the malware 204 repeatedly acquires the random number data 524 of the shared area 323, as shown in FIG. 11, the random number data (R ₀ , R ₁ , ) and the random number data (R′ ₀ , R′ ₁ , . In this way, the acquired random number data do not match, so even if the malware 204 acquires the key generation information (step S22), the random number indicated by the key generation information can be properly grasped. Therefore, it is unlikely that a key similar to the key shared between the first key sharing program 321 and the second key sharing program can be generated. Therefore, a key can be safely shared among multiple programs. Therefore, it is possible to reduce the risk of data encrypted using the key shared by the first key sharing program 321 and the second key sharing program leaking to the malware 204 .

In particular, increasing the number of repetitions of sending and receiving random number data 524 lowers the probability that malware 204 can eavesdrop on the same random number data as second key sharing program 324 . That is, the probability that a key similar to the key shared by the first key sharing program 321 and the second key sharing program can be generated becomes lower. Therefore, the key can be shared more securely among multiple programs.

Next, in the above embodiment, by impersonating the malware 204 that performs a man-in-the-middle attack on the terminal 102, that is, the first key sharing program 321 and the second key sharing program 324, an attempt is made to share the key with each key sharing program. A countermeasure against the presence of malware 204 that

FIG. 12 is a sequence diagram illustrating an example of key sharing processing when there is malware impersonating the first key sharing program, according to one embodiment. Note that processing similar to the key sharing processing shown in FIG. 9 is given the same reference numerals, and redundant description is omitted.

In this embodiment, as a measure against man-in-the-middle attacks by the malware 204, the second key sharing program 324 recognizes the delivery start request to be sent to the first key sharing program 321 as the first key sharing program 321 itself. The program (in some cases, the program impersonated by the malware 204) as well as other programs are transmitted so that they can be received. This can appropriately prevent the delivery start request from being sent only to the malware 204 impersonating the first key sharing program 321 .

For example, the second key sharing program 324 sends a delivery start request to all running programs. This can be realized by having the program 321 repeatedly acquire the delivery start request from the shared area 323 . As a method of transmitting a delivery start request to all running programs, for example, when transmitting a delivery start request as a signal, signal broadcasting can be used.

In order for malware 204 to share a key with second key sharing program 324 , malware 204 impersonates first key sharing program 321 and exchanges random number data 524 and key generation information 525 with second key sharing program 324 . need to interact with By taking measures against man-in-the-middle attacks described above, when the second key sharing program 324 sends a delivery start request (steps S11 and S31), not only the malware 204 impersonating the first key sharing program 321 but also , the first key sharing program 321 can also receive the delivery start request.

In this case, the malware 204 and the first key sharing program 321 each repeatedly write random number data to the shared area 323 (steps S12 and S32).

At this time, in the shared area 323, the random number data ( _W'0 , _W'1 , ..., _W'm ) written by the malware 204 and the random number data (W'm) written by the first key sharing program 321 are stored. W ₀ , W ₁ , . . . , W _n ) is stored.

Here, in the terminal 102, the OS 304 determines a program that can access resources based on information in the terminal 102 as needed. For this reason, when a plurality of programs repeat the process of issuing access requests to the same resource (here, the shared area 323) to the OS 304, the order in which the programs access the resource is always different. For this reason, when the first key sharing program 321 and the second key sharing program 324 repeatedly access the shared area 323, the malware 204 that can access the shared area 323 can access the shared area 323 like these programs. Even if accesses to the shared area 323 are repeated, the order of programs that can access the shared area 323 is determined as needed by the OS 304 .

_Therefore , when the second key sharing program 324 acquires the random number data (R ₀ , R ₁ , . Or, it is unlikely that only the random number data written by the first key sharing program 321 is used. _That is _, the random number data (R ₀ , R ₁ , _. , W _n ) and part of the random number data (W′ ₀ , _W ′ ₁ , .

In such a state, the second key sharing program 324 uses the acquired random number data 524 to generate the second key 713 .

For example, even when the malware 204 acquires data on the shared area 323, all random number data ( _W0 , _W1 , . . . , _Wn ) written to the shared area 323 by the first key sharing program 321 cannot be obtained, even if the key generation information 525 is obtained from the shared area 323 (step S33), the second key 713 generated by the second key sharing program 324 cannot be generated. That is, since the malware 204 cannot share a key with the second key sharing program 324, it cannot carry out a man-in-the-middle attack.

Also, if the malware 204 has written the random number data 524 to the shared area 323, there is a possibility that the random number data written by the malware 204 is included in the random number data used by the second key sharing program 324 to generate the key. In this case, since the first key sharing program 321 does not know the value of the random number data written by the malware 204, key sharing between the first key sharing program 321 and the second key sharing program 324 are also likely to fail.

Therefore, the first key sharing program 321 and the second key sharing program 324 may use the MAC described with reference to FIG. 10 to check whether the mutual key sharing has been successful. As a result, when it is confirmed that the key sharing has failed, for example, the first key sharing program 321 and the second key sharing program 324 share the created first key 503 and second key 713. It may be discarded and the key sharing process may be performed again.

In the above embodiment, the malware also acquires random number data from the shared area, transmits key generation information generated from the acquired random number data to the first key sharing program, and the first key sharing program transmits it from the second key sharing program. If the malware obtains the key generation information sent by the malware before obtaining the key generation information sent by the malware, the malware may impersonate the second key sharing program and successfully share the key with the first key sharing program. could be. This is because the malware does not need to acquire the same random number data as the random number data acquired by the second key sharing program.

As a method of more effectively preventing malware from spoofing the second key sharing program, the process of generating and obtaining random number data in the key sharing process of FIG. 9 is reversed, that is, The first key sharing program 321 acquires the random number data generated by the second key sharing program 324 side, and the first key sharing program 321 and the second key sharing program 324 use the random number data 712 generated by both. A key sharing process (second modification) is conceivable in which the first key 503 and the second key 713 are generated by using the keys.

In the second modification, the first key sharing program 321 includes a random number data acquisition unit 321 and a key generation information distribution unit 433, and the second key sharing program 324 includes a random number data generation/distribution unit 400 and a key generation information acquisition unit. 411 included.

FIG. 13 is a sequence diagram of key sharing processing according to the second modification. Note that processing similar to the key sharing processing shown in FIG. 11 is given the same reference numerals, and redundant description is omitted.

After receiving the key generation information, the first key sharing program 321 transmits a random number data delivery start request to the second key sharing program 324 (step S17).

Upon receiving the delivery start request, the second key sharing program 324 executes a process of repeatedly writing random number data to the shared area 323 (step S18).

Here, in FIG. 13, the random numbers transmitted by the second key sharing program are represented as r'0, r'1, . . . in the order of generation.

In the example of FIG. 13 , the second key sharing program 324 repeats the process of generating random number data and storing it in the shared area 323 until it receives a delivery end request from the first key sharing program 321 .

On the other hand, the first key sharing program 321 repeatedly executes the process of acquiring random number data from the shared area 323 (step S19).

After that, when the first key sharing program 324 acquires random number data of a size sufficient for key generation, it sends a delivery end request to the second key sharing program 324 (step S20). As a result, the second key sharing program 324 terminates the random number data generation process.

Next, the first key sharing program 321 generates a new first key 503 using all or part of the obtained random number data and the first key 503 . At this time, the first key sharing program does not generate the first key after step S16, and after step S19, generates all or part of the random number data obtained in step S19 and the random number associated with the key generation information received in step S16. may be used to generate the first key 503 .

Further, the first key sharing program 321 writes the index number included in the random number data used for generating the first key among the random number data obtained in step S19 as key generation information in the shared area 323 (step S21).

On the other hand, the second key sharing program 324 acquires key generation information from the shared area 323 (step S22).

After that, the second key sharing program 324 acquires the random numbers used by the first key sharing program 321 to generate the first key based on the key generation information, and uses these random numbers and the second key 713 to generate a new key. to generate a second key. At this time, the second key sharing program does not generate the second key after step S14, and associates all or part of the random number data obtained in step S13 with the key generation information received in step S22 after step S22. A random number may be used to generate the second key 713 .

In FIG. 13, steps S17 to S22 are performed after steps S11 to S16 are performed, but steps S11 to S16 may be performed after steps S17 to S22 are performed, or steps S11 to S16 may be performed. and step S17 to step S22 may be performed in parallel.

In the second modification, in order for the malware to impersonate the second key sharing program and successfully share the key with the first key sharing program, the malware repeatedly writes random number data to the shared area 323 in step S18, All of the random number data that the key sharing program acquires in step S19 must be written by malware. The OS 304 randomly determines the programs that can access the shared area based on the information in the terminal 102, and cannot determine the timing at which the programs access the shared area. Therefore, when malware and the second key sharing program repeatedly write random number data to the shared area 323, there is a possibility that all of the random number data acquired from the shared area 323 by the first key sharing program was written by malware. is low. Therefore, in the second modified example, the first key sharing program and the second key sharing program can safely share keys even if malware masquerading as the second sharing program is operating in the terminal 102 .

Next, key sharing processing according to the third modification will be described.

Here, attention is paid to a method of generating the seed 501 from the entropy source generated by the entropy generator 302 .

For example, seed 501 must have sufficient entropy for random number generation, and entropy The source can be used as seed 501 as it is. However, when the entropy source does not have enough entropy, it is necessary to repeatedly collect the entropy source from the entropy generator 302 and use the collected entropy source to generate the seed 501 .

Here, the first key sharing program 321 collects entropy sources after being activated. Generally, it takes time to obtain the entropy sources from the entropy generator 302. If you do not have enough entropy for , the time taken for key agreement increases.

Therefore, in the third modified example, the entropy source is started before the first key sharing program 321 is started, for example, when the terminal 102 is started, and the first key sharing program 321 A value with a large entropy size (hereinafter referred to as "seed generation information") is delivered to the first key sharing program 321 to generate the seed 501 using the seed generation information.

FIG. 14 is a sequence diagram of key sharing processing according to the third modification. Note that processing similar to the key sharing processing shown in FIG. 9 is given the same reference numerals, and redundant description is omitted.

For example, immediately after the terminal 102 is activated, the entropy source acquisition program 1400 (more precisely, the CPU 206 executing the entropy source acquisition program 1400) extracts the entropy sources (e ₀ , e ₁ , . . . ) from the entropy generator 302 . e _p ) is obtained (step S41).

After that, when the first key sharing program 321 is activated, the first key sharing program 321 transmits a seed delivery start request for requesting start of seed delivery to the entropy source acquisition program 1400 (step S42).

When the entropy source acquisition program 1400 receives a seed delivery start request from the first key sharing program 321, the acquired entropy source is used to generate a value (referred to as “seed generation information”) for generating a seed with high entropy. ₀ , s ₁ , . . . ). Next, the entropy source acquisition program 1400 stores the generated seed generation information (s ₀ , s ₁ , . . . ) in a shared area (for example, the first key sharing program 321 and the second key sharing program 324 in the shared area 323) is repeated (step S43).

Here, the seed generation information may be, for example, a pseudorandom number generated by an entropy source generated by a pseudorandom number generator as an example of the entropy generator 302 . The shared area between entropy source acquisition program 1400 and first key sharing program 321 is a different area from shared area 323 used for key sharing between first key sharing program 321 and second key sharing program 324. good too.

On the other hand, the first key sharing program 321 repeats collection of seed generation information from the shared area 323 with the entropy source acquisition program 1400 (step S44). Note that the first key sharing program 321 does not have to acquire all the seed generation information written in the shared area 323 by the entropy source acquisition program 1400 .

Next, the first key sharing program 321 collects seed generation information having a sufficient entropy size for generating the seed 501, and then transmits a seed delivery termination request to the entropy source acquisition program 1400 to request termination of seed delivery. (step S45). As a result, upon receiving the seed delivery end request, the entropy source acquisition program 1400 ends the writing of the seed generation information to the shared area 323 .

After that, the random number generation unit 402 of the first key sharing program 321 generates a seed 501 from the seed generation information and performs key sharing with the second key sharing program 324 .

In the above process, the entropy of the seed generation information written in the shared area 323 by the entropy source acquisition program 1400 is much larger than the entropy of the entropy source. Therefore, according to the above processing, it is possible to reduce the number of times values having entropy are collected in order to generate the seed 501 . Therefore, the first key sharing program 321 can generate and use the seed 501 at high speed.

Next, key sharing processing according to the fourth modification will be described.

In the above embodiment, the malware 204 is composed of many programs, and when these programs work together, the malware can access the shared area 323 more than the first key sharing program 321 and the second key sharing program 324. Since the number of times increases, the security of key sharing decreases. On the other hand, for example, the following may be done. The first key sharing program periodically attempts to access the shared area 323 and measures the interval at which access is actually successful. This may be measured by a timer that the CPU 206 has, for example. As the number of programs operating in the terminal 102 increases, the interval at which this access succeeds increases. Therefore, the first key sharing program 321 can detect the presence of the malware 204 when the access interval increases.

The second key sharing program may have this malware detection function, or a new program (detection program) may have the malware detection function. At this time, when the detection program detects malware 204, the detection program sends a signal notifying that the malware has been detected to the first key sharing program 321 and the second key sharing program 324. 324 can detect malware 204 .

Next, key sharing processing according to the fifth modification will be described.

In the above embodiment, as the number of random number data 524 transmitted by the first key sharing program 321 increases, the random number data stored in the random number data table 711 in the general-purpose register 303 increases. usage rate will increase. On the other hand, for example, the following may be done. In step 603 of FIG. 6, the random number generation unit 402 uses a pseudo-random number generator to generate random numbers from the index information generated by the index generation unit 403 and the seed 501, so that the process of step 605 is not performed. Here, it is assumed that the pseudo-random number generator can generate the same random number by inputting the same index information and seed 501 .

Then, the first key generation unit 412 uses a pseudo-random number generator to generate random numbers from each index information of the key generation information 525 and the seed 501, and uses these random numbers to generate the first key 503. can be

By doing so, the general-purpose register 303 does not need to have the random number data table 711, so that the usage rate of the general-purpose register 303 can be reduced, and the key can be shared in a short time.

Next, key sharing processing according to the sixth modification will be described.

In the above embodiment, the second key is generated from the collected random number data 712 by the second key generation unit 432 after the random number data acquisition unit 431 has finished collecting the random number data in the random number data pool 711 in the general-purpose register 303 . However, the usage rate of the general-purpose register 303 increases in proportion to the increase in the number of random number data to be collected. On the other hand, for example, the following may be done. In step 802 of FIG. 8, after the random number data acquisition unit 431 acquires the random number data 524 on the shared area, the random number included in this random number data and the second key 713 generated from the random numbers acquired so far are used to generate a new first key. 2 key 713 is generated, and the index information included in the random number data is newly added to the key generation information 714 . Subsequently, at step 803 in FIG. 8, it is determined from the number of index information included in the key generation information 714 whether a random number having a size sufficient for key generation has been obtained. As a result, the random number data pool 711 becomes unnecessary, and the usage rate of the general-purpose register 303 can be reduced.

Further, two or more of the above embodiment and the first to sixth modifications can be combined.

For example, by combining the fifth and sixth modifications with the second modification of the above-described embodiment, it is possible to reduce the usage rate of the general-purpose register 303 and safely perform key sharing from malware that spoofs or eavesdrops. . As this combination method, for example, the first key sharing program 321 generates a temporary key 1 using the key generation information 525 delivered by the second key sharing program 324, and uses the random number data 524 delivered by the second key sharing program 324 to Temporary key 2 may be generated sequentially, the first key may be generated from temporary key 1 and temporary key 2, and the second key sharing program 324 may generate the second key by reversing this subject. .

Next, another embodiment in which the functions of the present invention are added to two programs already installed on the terminal 102 (for example, the sensor program 211 and the authentication program 212) will be described in detail.

FIG. 15 is an example of a functional configuration diagram realized by the first key sharing program and the second key sharing program according to this embodiment.

The first data security processing program 1500 includes, for example, a first program processing unit 1501 that processes the sensor program 211 and a first key sharing program 321 .
The second data security processing program 1510 includes, for example, a 2-program processing unit 1511 that processes the authentication program 212 and a second key sharing program 324 .
When the installed first program processing unit 1501 sends data (for example, sensor data 203 ) to the second program processing unit 1511 , it passes data that requires confidentiality processing to the first data confidentiality processing unit 420 .
The first data encryption processing unit 420 performs encryption processing on the data acquired from the first program processing unit 1501 using the shared key through the processing described in the above embodiment.
The first data encryption processing unit 420 passes the encrypted data to the second data encryption processing unit 440 using the shared area 323, for example.
The second data encryption processing unit 440 restores the original data from the obtained encryption-processed data using the shared key through the processing described in the above embodiment, and passes the restored data to the second program processing unit 1511 .
When data is sent from the second program processing unit 1511 to the first program processing unit 1501, the same processing as described above may be performed with the subjects reversed.

Also in the present embodiment, it is possible to apply one or more of the first to sixth modified examples in combination. It is also possible to combine the above two embodiments.
By the above processing, safe data exchange becomes possible even between two programs in which one or both of them have already been installed.

Further, in each of the above embodiments, the first key sharing program 321 (or the first data security processing program 1500) and the second key sharing program 324 (or the second data security processing program 1510) are arranged in the same terminal 102. and run it. However, it is not limited to this. The program 324 (or the second data security processing program 1510) may be arranged and executed on another terminal.
In this case, the shared area 323 may be provided in the memory of any terminal. For example, if a shared area is provided in the memory of the terminal that executes the second key sharing program 324 (or the second data security processing program 1510), the first key sharing program 321 will receive a random number The data 524 may be stored in the shared area 323 and the key generation information may be obtained from the shared area 323 .

Although the above disclosure has been described with respect to exemplary embodiments, those skilled in the art will appreciate that various changes and modifications can be made in form and detail without departing from the spirit or scope of the disclosed subject matter. would do.
Further, in the above embodiments, part or all of the processing performed by the CPU may be performed by a dedicated hardware circuit. Also, the programs in the above embodiments may be installed from program sources. A program source may be a program distribution server or a non-transitory storage medium (for example, a portable storage medium).

Claims (12)

An information processing system comprising a main memory storing data and programs, and a processor connected to the main memory and executing the programs,
an OS (operating system) for allocating resources including the processor and the main storage device to the program to be executed based on predetermined allocation criteria;
comprising a first key sharing program and a second key sharing program for sharing a key and executing processing;
The processor executes the OS,
setting a shared area that can be shared for processing by the first key sharing program and the second key sharing program;
Allocating resources to the first key agreement program;
Allocating resources to the second key agreement program;
The processor executes the OS,
By executing the first key sharing program, the second key sharing program generates random number data capable of specifying a random number for generating a second key, and stores the random number data in the shared area; repeat
The processor executes the OS,
Repeating obtaining random number data stored in the shared area by executing the second key sharing program,
generating the second key based on the obtained plurality of random number data;
generating key generation information capable of identifying the obtained plurality of random number data used to generate the second key;
storing the key generation information in the shared area;
The processor executes the OS,
An information processing system that generates a first key based on the key generation information stored in the shared area by executing the first key sharing program. 2. The information processing system according to claim 1, wherein the process of allocating resources by executing the OS is not a process of allocating the resources to each program in a fixed order. 2. The information processing system according to claim 1, wherein said processor selects one or more pieces of random number data to be used for key generation from among a plurality of pieces of random number data, and generates said second key. one piece of random number data is data smaller than the data size required to generate the second key;
4. The information processing system according to claim 3, wherein said processor generates said key based on a plurality of pieces of random number data having a data size equal to or larger than the data size necessary for generating said second key. The main storage device is
including a kernel area for the OS,
the processor includes registers for storing data;
2. The information processing according to claim 1, wherein said processor saves and stores data stored in said register in said kernel area when a resource is allocated to a program different from the program being executed. system. The processor
2. Confirming whether or not said first key generated by executing said first key sharing program and said second key generated by executing said second key sharing program are the same. The information processing system according to . The processor
a first message authentication code generated based on the first key generated by executing the first key sharing program and a predetermined message; and the first message authentication code generated by executing the second key sharing program 7. The information processing system according to claim 6, wherein it is confirmed whether or not the second key and the second message authentication code generated based on the predetermined message are the same. The processor
When the first key generated by executing the first key sharing program and the second key generated by executing the second key sharing program are not the same, the first key sharing program and 7. The information processing system according to claim 6, wherein the process of generating the key by means of the second key sharing program is executed from the beginning. The processor
Securing data exchanged with the second key sharing program via the main storage device by executing the OS, allocating resources to the first key sharing program, and using the first key and
The processor
2. The apparatus according to claim 1, wherein said OS is executed, resources are allocated to said second key sharing program, and data exchanged with said first key sharing program is encrypted using said second key. information processing system. The information processing system is
2. The information processing system according to claim 1, which is realized by a single information processing device. An inter-program key sharing method by an information processing system comprising a main memory storing data and a program, and a processor connected to the main memory and executing the program,
an OS (operating system) for allocating resources including the processor and the main storage device to the program to be executed based on predetermined allocation criteria;
comprising a first key sharing program and a second key sharing program for sharing a key and executing processing;
By executing the OS,
setting a shared area that can be shared for processing by the first key sharing program and the second key sharing program;
Allocating resources to the first key agreement program;
Allocating resources to the second key agreement program;
By executing the OS,
By executing the first key sharing program, the second key sharing program generates random number data capable of specifying a random number for generating a second key, and stores the random number data in the shared area; repeat
By executing the OS,
Repeating obtaining random number data stored in the shared area by executing the second key sharing program,
generating the second key based on the obtained plurality of random number data;
generating key generation information capable of identifying the obtained plurality of random number data used to generate the second key;
storing the key generation information in the shared area;
By executing the OS,
An inter-program key sharing method for generating a first key based on the key generation information stored in the shared area by executing the first key sharing program. An inter-program key sharing program to be executed by a computer comprising a main memory storing data and a program, and a processor connected to the main memory and executing the program,
The inter-program key sharing program includes a first key sharing program and a second key sharing program for sharing keys and executing processing,
The first key sharing program is
to the computer;
When resources are allocated by the OS, the second key sharing program generates random number data capable of specifying a random number for generating a second key, and stores the random number data in a shared area of the main storage device; repeatedly execute
The second key sharing program is
to the computer;
repeatedly executing acquisition of random number data stored in the shared area when resources are allocated by the OS;
generating the second key based on the obtained plurality of random number data;
generating key generation information capable of identifying the obtained plurality of random number data used to generate the second key;
storing the key generation information in the shared area;
The first key sharing program is
to the computer;
An inter-program key sharing program for generating a first key based on the key generation information stored in the shared area when resources are allocated by execution of the OS.

Images