Method, System, and Computer-Readable Medium for Server Authentication Based on a Root Public Key

Abstract

A control method, system, and recording medium for root public key-based server authentication are provided. The control method comprises the steps of: an app management server generating a root key consisting of a pair of a root public key and a root private key; an app management server configuring an application to include the root public key; a user terminal downloading and storing the application; a service server receiving a server certificate signed with a root private key corresponding to the root public key from the app management server; a service server transmitting the issued server certificate to the user terminal; a user terminal performing verification of the server certificate using the root public key stored in the application; and, if the signature verification is successful, the user terminal performing encrypted communication at the application layer using the server public key included in the server certificate.

Description

Technology Field

[0001] The present disclosure relates to a control method, system, and recording medium for root public key-based server authentication. Background Technology

[0002] Public Key Infrastructure (PKI) is widely used as a conventional server authentication technology. In PKI, the server certificate presented by the server is verified through a certificate chain to determine whether it was issued by a trusted Certificate Authority (CA). For example, a client (i.e., a user terminal) determines the trustworthiness of a server by sequentially verifying the server certificate, intermediate CA certificates, and root CA certificate. In such PKI-based authentication methods, the operating system or web browser manages a root certificate store that stores multiple root CA certificates, and the client uses the root certificates contained in that store as the standard of trust.

[0003] However, in this structure, since all root certification authority certificates pre-installed in the system must be trusted, there is a problem where, from the application's perspective, even server certificates issued by unintended certification authorities are trusted. In reality, operating systems and browser environments have dozens to hundreds of root certification authority certificates pre-installed, and it is difficult for application developers to control these authorities individually.

[0004] To address the limitations of the aforementioned PKI structure, Certificate Pinning technology has been proposed to restrict trust to specific servers or services. Certificate Pinning is a method in which a specific server certificate or its public key information is stored in advance within a client application, and communication is permitted only when the certificate presented by the server matches the stored information. Furthermore, to mitigate maintenance issues associated with Certificate Pinning, CA Pinning technology has been proposed, which fixes the Certificate Authority (CA) certificate to the application instead of the server certificate. Alternatively, Self-Signed Certificate technology has been proposed, in which the server or developer directly generates and signs the certificate without going through an accredited Certificate Authority.

[0005] However, the aforementioned conventional technologies had limitations in that it was difficult for application developers to directly control the scope of trust for server authentication, frequent application updates were required when server certificates or public keys were changed, multiple external certification authorities had to be trusted due to reliance on the PKI structure, and external infrastructure such as OCSPs or CRLs had to be relied upon for certificate revocation.

[0006] Therefore, in environments where applications and service servers communicate based on predefined trust relationships, there is a need for simpler and more efficient technology capable of performing server authentication and secure encrypted communication without relying on a PKI structure. The problem to be solved

[0007] The present disclosure aims to solve the problems of the prior art as described above by providing a control method, a system, and a recording medium that can provide a simpler and more efficient server authentication structure by performing server authentication based on a root public key included in an application. means of solving the problem

[0008] A control method for authenticating a service server in a system comprising an app management server, a user terminal, and a service server according to one embodiment of the present disclosure comprises: (a) the app management server generating a root key consisting of a pair of a root public key and a root private key; (b) the app management server configuring an application to include the root public key; (c) the user terminal downloading and storing the application; (d) the service server receiving a server certificate signed with a root private key corresponding to the root public key from the app management server; (e) the service server transmitting the issued server certificate to the user terminal; (f) the user terminal performing verification of the server certificate using the root public key stored in the application; and (g) if the signature verification is successful, the user terminal performing encrypted communication at the application layer using the server public key included in the server certificate.

[0009] When an event to revoke the server certificate occurs by the service server, the service server requests the app management server to replace the server certificate; the app management server records information regarding the server certificate in a certificate revocation list; the service server receives a new server certificate signed with a root private key corresponding to the root public key from the app management server; the app management server updates the application based on the certificate revocation list; and the user terminal downloads the updated application.

[0010] The above user terminal may not verify server certificates that have expired based on the certificate revocation list included in the above updated application.

[0011] The above app management server can delete expired revoked certificates from the certificate revocation list during the next update.

[0012] When an event occurs to replace the root key, the app management server generates a new root key consisting of a pair of a new root public key and a new root private key; and the app management server updates an application to include the new root public key; wherein a server certificate signed with the root public key may be excluded from the trusted target.

[0013] The above step (f) may include a step in which the user terminal additionally verifies the server identification information and validity period included in the server certificate, along with the signature verification of the server certificate.

[0014] The encrypted communication performed in step (g) above may include an electronic envelope method that encrypts data using a symmetric key encryption algorithm and encrypts the symmetric key with the server's public key to transmit it.

[0015] Step (b) above may configure the application so that the root public key is included in the form that cannot be tampered with.

[0016] A system comprising an app management server, a user terminal, and a service server according to one embodiment of the present disclosure, wherein the app management server generates a root key consisting of a pair of a root public key and a root private key and configures an application to include the root public key; the user terminal downloads and stores the application and performs signature verification on a server certificate received from the service server using the root public key stored in the application; the service server is configured to receive a server certificate signed with a root private key corresponding to the root public key from the app management server and transmit it to the user terminal; and if the signature verification is successful, the user terminal performs encrypted communication at the application layer using the server public key included in the server certificate.

[0017] When an event occurs to revoke the server certificate by the service server, the service server requests the app management server to replace the server certificate, the app management server records information regarding the server certificate in a certificate revocation list, updates the application based on the certificate revocation list, the service server receives a new server certificate signed with a root private key corresponding to the root public key from the app management server, and the user terminal can download the updated application.

[0018] The above user terminal may not verify server certificates that have expired based on the certificate revocation list included in the above updated application.

[0019] The above app management server can delete expired revoked certificates from the certificate revocation list during the next update.

[0020] When an event occurs to replace the root key, the app management server generates a new root key consisting of a pair of a new root public key and a new root private key, the app management server updates the application to include the new root public key, and the server certificate signed with the root public key may be excluded from the trusted list.

[0021] The above user terminal may be configured to additionally verify the server identification information and validity period included in the server certificate, along with the signature verification of the server certificate.

[0022] The encrypted communication at the application layer described above may include an electronic envelope method that encrypts data using a symmetric key encryption algorithm and encrypts the symmetric key with the server's public key for transmission.

[0023] The above application may be configured to include the root public key in a form that cannot be tampered with.

[0024] A computer-readable recording medium storing instructions for controlling a computer to execute a control method for authenticating a service server in a system comprising an app management server, a user terminal, and a service server according to one embodiment of the present disclosure comprises: (a) the app management server generating a root key consisting of a pair of a root public key and a root private key; (b) the app management server configuring an application to include the root public key; (c) the user terminal downloading and storing the application; (d) the service server receiving a server certificate signed with a root private key corresponding to the root public key from the app management server; (e) the service server transmitting the issued server certificate to the user terminal; (f) the user terminal performing verification of the server certificate using the root public key stored in the application; and (g) if the signature verification is successful, the user terminal performing encrypted communication at the application layer using the server public key included in the server certificate. Effects of the invention

[0025] According to the present invention, by performing authentication for a service server based on a root public key included in an application and performing encrypted communication at the application layer, the reliability of server authentication can be improved and the burden of certificate management and maintenance can be effectively reduced without relying on PKI and external authentication infrastructure. Brief explanation of the drawing

[0026] FIG. 1 is a drawing illustrating a system for authenticating a service server according to one embodiment of the present disclosure. FIG. 2 is a block diagram showing the configuration of an app management server according to one embodiment of the present disclosure. FIG. 3 is a block diagram showing the configuration of a service server according to one embodiment of the present disclosure. FIG. 4 is a block diagram showing the configuration of a user terminal according to one embodiment of the present disclosure. FIG. 5 is a sequence diagram illustrating a control method for authenticating a service server according to one embodiment of the present disclosure. FIG. 6 is a sequence diagram illustrating a method for updating a server certificate and an application when a server certificate hacking is detected, according to one embodiment of the present disclosure. FIG. 7 is a sequence diagram illustrating a method for updating a server certificate and an application when a problem with the root key is detected, according to one embodiment of the present disclosure. Specific details for implementing the invention

[0027] The present disclosure will be described in detail below with reference to the attached drawings.

[0028] The terms used in the embodiments of this disclosure have been selected to be as widely used as possible, taking into account their functions within this disclosure; however, these terms may vary depending on the intent of those skilled in the art, case law, the emergence of new technologies, etc. Additionally, in specific cases, terms may be arbitrarily selected by the applicant, and in such cases, their meanings will be described in detail in the description section of the disclosure. Therefore, terms used in this disclosure should be defined not merely by their names, but based on their meanings and the overall content of this disclosure.

[0029] In this specification, expressions such as “have,” “may have,” “include,” or “may include” indicate the presence of the feature (e.g., a numerical value, function, operation, or component, etc.) and do not exclude the presence of additional features.

[0030] The expression "at least one of A or / and B" should be understood as representing either "A" or "B" or "A and B".

[0031] Expressions such as "first," "second," "first," or "second" used in this specification may modify various components regardless of order and / or importance, and are used only to distinguish one component from another and do not limit said components.

[0032] Where it is stated that a component (e.g., a first component) is "(operatively or communicatively) coupled with / to" or "connected to" another component (e.g., a second component), it should be understood that the component may be directly connected to the other component or connected through the other component (e.g., a third component).

[0033] The singular expression includes the plural expression unless the context clearly indicates otherwise. In this application, terms such as “comprising” or “consisting of” are intended to specify the existence of the features, numbers, steps, actions, components, parts, or combinations thereof described in the specification, and should be understood as not precluding the existence or addition of one or more other features, numbers, steps, actions, components, parts, or combinations thereof.

[0034] In the embodiments, a "module" or "part" performs at least one function or operation and may be implemented in hardware or software, or a combination of hardware and software. Additionally, a plurality of "modules" or a plurality of "parts" may be integrated into at least one module and implemented by at least one processor, except for a "module" or "part" that needs to be implemented in specific hardware.

[0036] FIG. 1 is a diagram illustrating a system for authenticating a service server according to one embodiment of the present disclosure. As illustrated in FIG. 1, the system may include an app management server (100), a service server (200), and a user terminal (300). The system of the present disclosure may have a structure for performing reliable authentication of the service server (200) in the application environment of the user terminal and providing end-to-end encrypted communication at the application layer.

[0037] The app management server (100) may be a server responsible for the distribution and security management of applications. The app management server (100) may be implemented as a single server, but this is merely one embodiment, and it is obvious that it may be implemented as a plurality of servers.

[0038] The app management server (100) can generate a root key consisting of a pair of a root public key and a root private key, and configure the application to include the generated root public key. At this time, the root public key can be stored (or included) within the application in a form that cannot be tampered with. Additionally, the app management server (100) can use the root private key to sign and issue a server certificate provided to the service server (200).

[0039] The service server (200) may be a server that provides various services (e.g., financial services, etc.) to the user terminal (300). The service server (200) may also be implemented as a single server, but this is merely one embodiment, and it is obvious that it may be implemented as a plurality of servers.

[0040] Additionally, the service server (200) may receive a server certificate signed with a root private key from the app management server (100). The service server (200) transmits the issued server certificate to the user terminal (300), and the user terminal (300) can verify it using the root public key stored in the application. Once verification is complete, the service server (200) performs encrypted communication with the user terminal (300) at the application layer using the server public key included in the server certificate.

[0041] A user terminal (300) is a portable terminal such as a smartphone or tablet, and downloads and stores an application from an app management server (100). The user terminal (300) can perform signature verification on a server certificate received from a service server (200) using a root public key embedded in the application. If signature verification is successful, the user terminal (300) identifies the server public key included in the server certificate as a trusted key and can perform encrypted communication at the application layer using the server public key.

[0042] That is, a system according to one embodiment of the present disclosure can perform server authentication and encrypted communication at the application layer without relying on existing Transport Layer Security (TLS)-based Transport Layer authentication.

[0043] As a result, the service server can be authenticated based on a root public key directly managed by the application manufacturer, without relying on trust in multiple root Certificate Authorities (CAs) embedded in the operating system (OS) or browser. Consequently, the system can effectively block Man-in-the-Middle (MITM) attacks or attacks using untrusted server certificates, and can improve end-to-end security between the user terminal (300) where the application is installed and the service server (200).

[0044] FIG. 2 is a block diagram showing the configuration of an app management server according to one embodiment of the present disclosure. The app management server (100) may include a communication interface (110), a memory (120), and a processor (130). However, this is merely one embodiment, and it is obvious that other components may be added when the app management server (100) is implemented as a different electronic device.

[0045] The communication interface (110) can communicate with various external devices (e.g., a service server (200), etc.). In one or more embodiments, the communication interface (110) can communicate with various external devices using various wireless communication technologies or mobile communication technologies. Such wireless communication technologies may include, for example, Bluetooth, Bluetooth Low Energy, CAN communication, Wi-Fi, Wi-Fi Direct, ultrawide band (UWB), Zigbee, infrared data association (IrDA), or near field communication (NFC), and mobile communication technologies may include 3GPP, Wi-Max, LTE (Long Term Evolution), 5G, etc.

[0046] In one or more embodiments, the communication interface (110) may receive a request for server certificate issuance from the service server (200) and may transmit the server certificate to the service server (200).

[0047] The memory (120) can store instructions or data related to the operating system (OS) and the components of the app management server (100) for controlling the overall operation of the components of the app management server (100). In particular, the memory (120) may include various modules for service server authentication (e.g., configurations 131 to 136 shown in FIG. 2). In particular, when a preset event occurs, the app management server (100) can load data for various modules stored in non-volatile memory to perform various operations into volatile memory. Here, loading means the operation of loading and storing data stored in non-volatile memory into volatile memory so that at least one processor (130) can access it.

[0048] Meanwhile, the memory (120) may be implemented as non-volatile memory (e.g., hard disk, SSD (Solid state drive), flash memory), volatile memory (including memory within at least one processor (130)), etc.

[0049] At least one processor (130) can control the app management server (100) according to at least one instruction stored in memory (120).

[0050] In particular, at least one processor (130) may include one or more processors. For example, one or more processors may include one or more of a CPU (Central Processing Unit), GPU (Graphics Processing Unit), APU (Accelerated Processing Unit), MIC (Many Integrated Core), DSP (Digital Signal Processor), NPU (Neural Processing Unit), hardware accelerator, or machine learning accelerator. One or more processors may control one or any combination of other components of an electronic device and may perform operations or data processing related to communication. One or more processors may execute one or more programs or instructions stored in memory. For example, one or more processors may perform a method according to one embodiment of the present disclosure by executing one or more instructions stored in memory.

[0051] In embodiments of the present disclosure, at least one processor (130) may mean a system-on-chip (SoC) in which one or more processors and other electronic components are integrated, a single-core processor, a multi-core processor, or a core included in a single-core processor or a multi-core processor, wherein the core may be implemented as a CPU, GPU, APU, MIC, DSP, NPU, hardware accelerator or machine learning accelerator, etc., but the embodiments of the present disclosure are not limited thereto.

[0052] In one or more embodiments, at least one processor (130) may be configured to implement or perform a root key generation module (131), a server certificate issuance module (132), an application configuration / build module (133), an update / distribution module (134), a certificate revocation list management module (135), and a root key replacement management module (136) by executing instructions stored in memory (120), as illustrated in FIG. 2. Here, at least one processor (130) implements the modules by executing program instructions stored in memory (120), and the modules may be physically located inside or outside the processor as logical functional units.

[0053] The root key generation module (131) is a module for generating a root key that serves as a standard of trust in a public key-based cryptographic system, and performs the function of generating a pair of public and private keys. For example, a key pair for encryption can be generated using a cryptographically secure random number generator and a specific public key cryptographic algorithm (e.g., RSA, ECC, etc.). In one or more embodiments, the root key generation module (131) can generate a pair of a root public key (pk_R) and a root private key (sk_R) so that the application manufacturer can directly manage the standard of trust for authenticating the service server without relying on a root certificate store provided by an operating system or an external certification authority. Here, the root public key is a public key for verifying the signature of signed data (e.g., server certificate) and can be included in the application and distributed to the user terminal (300). The root private key is a private key corresponding to the root public key and can be used to sign the server certificate.

[0054] The server certificate issuance module (132) performs the function of generating a server certificate to identify a server and signing the certificate with a specific key. Here, the server certificate may include a server public key, server identification information, and a validity period. In one or more embodiments, the server certificate issuance module (132) may issue a server certificate directly signed for the server public key of the service server (200) using the root private key generated by the root key generation module (131). Since the server certificate issued at this time is generated directly by the app management server (100) without going through an external certification authority, the problem of trusting a third party certificate not managed by the application manufacturer can be prevented.

[0055] The application configuration / build module (133) performs the function of creating an executable file or package of the application and configuring resources and configuration information to be included in the application. In one or more embodiments, the application configuration / build module (133) can configure the application so that the root public key is included in the application in a form that cannot be tampered with. For example, the application configuration / build module (133) can configure the application so that the root public key can be included inside the application binary, in the signed resource area or the obfuscated code area. Through this, an application running on a user terminal (300) can perform authentication for a service server (200) based on a root public key without referring to the root certificate store of the operating system.

[0056] The update / distribution module (134) performs the function of distributing a new version or a modified version of the application to a user terminal. At this time, the application is updated through an app store or a dedicated distribution channel. In one or more embodiments, the update / distribution module (134) may distribute an application containing a certificate revocation list or a changed root public key to the user terminal (300) when a security event occurs, such as the replacement or revocation of a server certificate due to hacking of the service server (200). Through this, the user terminal (300) can perform authentication of the service server (200) based on the latest trust information without a separate network verification procedure.

[0057] The certificate revocation list management module (135) is a module for managing certificate information that is invalid or no longer trusted, and performs the function of storing and updating certificate identifiers and reasons for revocation, etc. In one or more embodiments, the certificate revocation list management module (135) can record a server certificate in the certificate revocation list if the server certificate has been leaked or needs to be replaced. This revocation list is included in the application when the application is updated and distributed to the user terminal (300), and the user terminal (300) can block the use of the revoked certificate by referring to the revocation list during the server certificate verification process.

[0058] The root key replacement management module (136) performs the function of generating a new root key and managing the existing root key so that it is no longer used when a root key is leaked or when a change in the password policy is required. In one or more embodiments, the root key replacement management module (136) can generate a new root key pair and control the distribution of an application containing the new root public key to a user terminal (300) via the update / distribution module (134) when an event occurs, such as a security incident of the root private key or a change in the password algorithm. At the same time, server certificates signed with the existing root public key can be managed so that they are no longer trusted.

[0060] FIG. 3 is a block diagram showing the configuration of a service server according to one embodiment of the present disclosure. The service server (200) may include a communication interface (210), a memory (220), and a processor (230). However, this is merely one embodiment, and it is obvious that other components may be added when the service server (200) is implemented as another electronic device (e.g., a desktop PC).

[0061] The communication interface (210) can communicate with various external devices (e.g., an app management server (100) or a user terminal (300), etc.). In one or more embodiments, the communication interface (210) can communicate with various external devices using various wireless communication technologies or mobile communication technologies. Such wireless communication technologies may include, for example, Bluetooth, Bluetooth Low Energy, CAN communication, Wi-Fi, Wi-Fi Direct, ultrawide band (UWB), Zigbee, infrared data association (IrDA), or near field communication (NFC), and mobile communication technologies may include 3GPP, Wi-Max, LTE (Long Term Evolution), 5G, etc.

[0062] In one or more embodiments, the communication interface (210) may transmit a request for the issuance of a server certificate to the app management server (100) and transmit a server certificate to the app management server (100). Additionally, the communication interface (210) may transmit a server certificate to a user terminal (300) and receive an electronic envelope containing encrypted data from the user terminal (300).

[0063] The memory (220) can store instructions or data related to the operating system (OS) for controlling the overall operation of the components of the service server (200) and the components of the service server (200). In particular, the memory (220) may include various modules for service server authentication (e.g., configurations 231 to 234 shown in FIG. 3). In particular, when a preset event occurs, the service server (200) may load data for various modules stored in non-volatile memory to perform various operations into volatile memory. Here, loading means the operation of loading and storing data stored in non-volatile memory into volatile memory so that at least one processor (230) can access it.

[0064] Meanwhile, the memory (220) may be implemented as non-volatile memory (e.g., hard disk, SSD (Solid state drive), flash memory), volatile memory (including memory within at least one processor (230)), etc.

[0065] At least one processor (230) can control the service server (200) according to at least one instruction stored in memory (220).

[0066] In particular, at least one processor (230) may include one or more processors. For example, one or more processors may include one or more of a CPU (Central Processing Unit), GPU (Graphics Processing Unit), APU (Accelerated Processing Unit), MIC (Many Integrated Core), DSP (Digital Signal Processor), NPU (Neural Processing Unit), hardware accelerator, or machine learning accelerator. One or more processors may control one or any combination of other components of an electronic device and may perform operations or data processing related to communication. One or more processors may execute one or more programs or instructions stored in memory. For example, one or more processors may perform a method according to one embodiment of the present disclosure by executing one or more instructions stored in memory.

[0067] In embodiments of the present disclosure, at least one processor (230) may mean a system-on-chip (SoC) in which one or more processors and other electronic components are integrated, a single-core processor, a multi-core processor, or a core included in a single-core processor or a multi-core processor, wherein the core may be implemented as a CPU, GPU, APU, MIC, DSP, NPU, hardware accelerator or machine learning accelerator, etc., but the embodiments of the present disclosure are not limited thereto.

[0068] In one or more embodiments, at least one processor (230) may be configured to implement or perform a server key pair generation / management module (231), a certificate issuance request module (232), a server certificate provision module (233), and an App-layer encryption / decryption module (234) by executing instructions stored in memory (220), as illustrated in FIG. 3. Here, at least one processor (230) implements the modules by executing program instructions stored in memory (220), and the modules may be physically located inside or outside the processor as logical functional units.

[0069] The server key pair generation / management module (231) is a module that generates and manages a pair of server public key and server private key for identifying the server and using for encrypted communication. For example, the server key pair generation / management module (231) generates a key pair using a server public key encryption algorithm (RSA, ECC, etc.), and the server private key is stored in the service server (200) so as not to be exposed externally. In one or more embodiments, the server key pair generation / management module (231) in the present invention can generate a server public key (pk_S) and a server private key (sk_S) for the service server (200) to perform encrypted communication with the user terminal (300) at the application layer. The generated server public key is included in the server certificate and provided to the user terminal (300), and the server private key is subsequently used for decryption in encrypted communication. Through this, communication security can be strengthened by using an independent encryption key for each server.

[0070] The certificate issuance request module (232) performs the function of generating a certificate issuance request including a server public key and transmitting it to a certificate issuing entity (e.g., an app management server (00)). In one or more embodiments, the certificate issuance request module (232) requests the issuance of a server certificate to the app management server (100), including a server public key generated by the server key pair generation / management module (231).

[0071] The server certificate providing module (233) performs the function of providing a server certificate held by the service server (200) to a client (e.g., user terminal (300)). In one or more embodiments, the server certificate providing module (233) transmits a server certificate issued and stored from the app management server (100) to the user terminal (300). Here, the user terminal (300) can perform encrypted communication only after verifying the trustworthiness of the service server (200) using the server certificate.

[0072] The App-layer encryption / decryption module (234) is a module that performs data encryption and decryption at the application layer independently of the transport layer (TLS / SSL).

[0073] In one or more embodiments, the App-layer encryption / decryption module (234) can perform application layer encrypted communication using a server public key and a server private key in communication with a user terminal (300). For example, data encrypted with a symmetric key generated by the user terminal (300) can be decrypted using the server private key. Through this, the present disclosure can provide encrypted communication associated with server authentication without relying on TLS.

[0075] FIG. 4 is a block diagram showing the configuration of a user terminal according to one embodiment of the present disclosure. The user terminal (300) may include a communication interface (310), a memory (330), and a processor (330). However, this is merely one embodiment, and it is obvious that other components may be added when the user terminal (300) is implemented as another electronic device (e.g., a desktop PC).

[0076] The communication interface (310) can communicate with various external devices (e.g., service server (200), etc.). In one or more embodiments, the communication interface (310) can communicate with various external devices using various wireless communication technologies or mobile communication technologies. Such wireless communication technologies may include, for example, Bluetooth, Bluetooth Low Energy, CAN communication, Wi-Fi, Wi-Fi Direct, ultrawide band (UWB), Zigbee, infrared data association (IrDA), or near field communication (NFC), and mobile communication technologies may include 3GPP, Wi-Max, LTE (Long Term Evolution), 5G, etc.

[0077] In one or more embodiments, the communication interface (310) may receive a server certificate from the service server (200) and transmit an electronic envelope containing encrypted data to the service server (200).

[0078] The memory (320) can store instructions or data related to the operating system (OS) for controlling the overall operation of the components of the user terminal (300) and the components of the user terminal (300). In particular, the memory (320) may include various modules for service server authentication (e.g., configurations 331 to 335 shown in FIG. 4). In particular, when a preset event occurs, the user terminal (300) can load data for various modules stored in non-volatile memory to perform various operations into volatile memory. Here, loading means the operation of loading and storing data stored in non-volatile memory into volatile memory so that at least one processor (330) can access it.

[0079] Meanwhile, the memory (320) may be implemented as non-volatile memory (e.g., hard disk, SSD (Solid state drive), flash memory), volatile memory (including memory within at least one processor (330)), etc.

[0080] At least one processor (330) can control the user terminal (300) according to at least one instruction stored in memory (320).

[0081] In particular, at least one processor (330) may include one or more processors. For example, one or more processors may include one or more of a CPU (Central Processing Unit), GPU (Graphics Processing Unit), APU (Accelerated Processing Unit), MIC (Many Integrated Core), DSP (Digital Signal Processor), NPU (Neural Processing Unit), hardware accelerator, or machine learning accelerator. One or more processors may control one or any combination of other components of an electronic device and may perform operations or data processing related to communication. One or more processors may execute one or more programs or instructions stored in memory. For example, one or more processors may perform a method according to one embodiment of the present disclosure by executing one or more instructions stored in memory.

[0082] In embodiments of the present disclosure, at least one processor (230) may mean a system-on-chip (SoC) in which one or more processors and other electronic components are integrated, a single-core processor, a multi-core processor, or a core included in a single-core processor or a multi-core processor, wherein the core may be implemented as a CPU, GPU, APU, MIC, DSP, NPU, hardware accelerator or machine learning accelerator, etc., but the embodiments of the present disclosure are not limited thereto.

[0083] In one or more embodiments, at least one processor (330) may be configured to implement or perform an app execution / storage module (331), a server certificate verification module (332), a server identification / validity period verification module (333), a revocation list inspection module (334), and an App-layer encryption communication module (335) by executing instructions stored in memory (320), as illustrated in FIG. 3. Here, at least one processor (330) implements the modules by executing program instructions stored in memory (320), and the modules may be physically located inside or outside the processor as logical functional units.

[0084] The app execution / storage module (331) is a module for storing and executing an application and manages application code and resources. In one or more embodiments, the app execution / storage module (331) can store and execute an application containing a root public key. The root public key included in the application is used as a standard for authentication to the service server (200), and the user terminal (300) can perform authentication to the service server (200) without referring to the root certificate store of the operating system.

[0085] The server certificate verification module (332) performs the function of verifying the signature of a certificate received from the service server (200) to determine the authenticity of the server certificate. In one or more embodiments, the server certificate verification module (332) performs signature verification for the server certificate using the root public key (pk_R) stored in the application. At this time, certificate chain verification may not be performed, and only single signature verification may be performed based on the root public key embedded in the application.

[0086] The server identification / validity verification module (333) performs the function of checking the server identification information and validity period included in the server certificate. In one or more embodiments, the server identification / validity verification module (333) checks whether the server domain, server ID, or service identifier included in the server certificate matches the current target server for connection, and can further verify whether the validity period of the certificate has not expired. Through this, even if the certificate has passed signature verification, it is possible to prevent connection to an inappropriate service server (200).

[0087] The revocation list inspection module (334) performs the function of inspecting a certificate revocation list to identify server certificates that are no longer trusted. In one or more embodiments, the revocation list inspection module (334) may inspect whether a received server certificate is subject to revocation by referring to a certificate revocation list provided through an application update.

[0088] The App-layer encrypted communication module (335) is a module that controls the transmission and reception of encrypted data at the application layer. In one or more embodiments, the App-layer encrypted communication module (335) can perform encrypted communication using an envelope encryption method. Specifically, the user terminal (300) can encrypt data using a randomly generated symmetric key (such as AES), encrypt the said symmetric key with a server public key (pk_S) included in the server certificate, and transmit it to the service server (200). The service server (300) can decrypt the symmetric key using a server private key (sk_S) and then decrypt the data using said symmetric key. Additionally, as an example, the App-layer encrypted communication module (335) can encrypt data using a homomorphic encryption method.

[0090] FIG. 5 is a sequence diagram illustrating a control method for authenticating a service server according to one embodiment of the present disclosure.

[0091] In the following embodiments, each operation may be performed sequentially, but is not necessarily performed sequentially. For example, the order of each operation may be changed, and at least two operations may be performed in parallel.

[0092] The app management server (100) can generate a root key consisting of a pair of a root public key and a root private key (505). At this time, the root private key is securely managed for issuing a server certificate, and the root public key can subsequently be included in an application and used for authentication of the service server (200) on a user terminal (300).

[0093] The app management server (100) can configure (or build) the application to include the root public key (510). Here, the application can be configured to store the root public key in a form that prevents tampering.

[0094] The user terminal (300) can download and store an application from the app management server (100) (515). Here, the user terminal (300) can download an application uploaded by the app management server (100) to the app store server, but this is merely one embodiment and the application can be downloaded from the app management server (100).

[0095] The service server (200) may request the app management server (100) to issue a server certificate (520). Here, the request for issuance may include the server public key and server identification information, but is not limited thereto.

[0096] The app management server (100) can sign and issue a server certificate using a root private key in response to an issuance request (525). In particular, the app management server (100) can issue a server certificate by generating server certificate data including the server public key, server identification information, and validity period information of the service server (200) in response to a server certificate issuance request received from the service server (200), and by performing an electronic signature on the server certificate data using the root private key.

[0097] The app management server (100) can transmit the issued server certificate to the service server (200) (530). The server certificate is transmitted with the root private key signed, and whether it has been tampered with during the transmission process can be verified later by the user terminal (300).

[0098] The service server (200) can transmit the issued server certificate to the user terminal (300) (535).

[0099] The user terminal (300) can perform a verification procedure for the service server (200) using the received server certificate (540). In particular, the user terminal (300) can verify (or authenticate) the service server by performing signature verification on the received server certificate using the root public key stored in the application. If signature verification fails, subsequent communication with the service server (200) may be blocked. If server authentication is successful, the user terminal (300) can perform encrypted communication with the service server (200).

[0100] The user terminal (300) can encrypt data to be transmitted using the server public key included in the server certificate (545). In one or more embodiments, the user terminal (300) can use an electronic envelope method that encrypts data using a symmetric key encryption algorithm and encrypts the symmetric key with the server public key.

[0101] The user terminal (300) can transmit the electronic envelope to the service server (200) (550). Here, the electronic envelope may contain encrypted data and an encrypted symmetric key.

[0102] The service server (200) can decrypt the encrypted data (555). Specifically, the service server (200) can decrypt the symmetric key contained in the electronic envelope using its own server private key and decrypt the encrypted data using the symmetric key.

[0103] The service server (200) can perform the requested service using the decrypted data (560). The service server (200) can also provide the result of the service execution to the user terminal (300).

[0105] FIG. 6 is a sequence diagram illustrating a method for updating a server certificate and an application when a server certificate hacking is detected, according to one embodiment of the present disclosure.

[0106] In the following embodiments, each operation may be performed sequentially, but is not necessarily performed sequentially. For example, the order of each operation may be changed, and at least two operations may be performed in parallel.

[0107] The service server (200) can detect hacking of the server certificate (610). For example, the service server (200) detects hacking of the server certificate based on certain security events, such as the possibility of server private key exposure, abnormal access, and signs of integrity compromise. For example, the service server (200) can perform hacking detection through an intrusion detection system (IDS), integrity verification, log analysis, abnormal traffic detection, etc.

[0108] The service server (200) may request the app management server (100) to replace the server certificate based on the hacking detection result (620). Here, the replacement request may include information about the server certificate to be revoked (e.g., server certificate identifier, etc.) and / or information regarding the server public key or public key generation request for issuing a new certificate.

[0109] The app management server (100) may, in response to a replacement request, record the server certificate that was previously issued and in use in the certificate revocation list (630). Here, the certificate revocation list is a set of information for identifying certificates that must be prohibited from use when the user terminal (300) verifies the server certificate, and may include, for example, information about the certificate to be revoked (e.g., the serial number of the certificate to be revoked, the revocation validity period, etc.).

[0110] The app management server (100) can issue a new server certificate (640). Specifically, the app management server (100) can issue a new server certificate by generating a new server certificate based on a new server public key or a previously registered server public key and signing it with a root private key. At this time, since the new server certificate includes a signature verifiable with the root public key, the user terminal (300) can subsequently verify the new server certificate using the root public key within the application.

[0111] The app management server (100) can transmit the newly issued server certificate to the service server (200) (650). The service server (200) can then provide the new server certificate to the user terminal (300) so that the new server certificate can be used instead of the existing certificate in communication with the user terminal (300).

[0112] The app management server (100) can update the application (660). Specifically, the app management server (100) can create and distribute an updated application so that the user terminal (300) does not use the revoked server certificate. For example, the updated application may be configured to include a certificate revocation list or to include data for referencing the certificate revocation list (e.g., revocation list hash, version information). Additionally, the updated application may be configured to further check whether the received server certificate is included in the certificate revocation list when verifying the server certificate.

[0113] The user terminal (300) can download and save the updated application (670). Then, when the user terminal (300) receives a server certificate from the service server (200), it can block access based on the revoked server certificate by performing not only signature verification using the root public key but also a check for inclusion in the certificate revocation list. That is, the user terminal (300) may not verify the server certificate that has expired based on the certificate revocation list included in the updated application.

[0114] Meanwhile, the app management server (100) can delete expired revoked certificates from the certificate revocation list during the next update. This prevents the certificate revocation list from continuously increasing.

[0116] FIG. 7 is a sequence diagram illustrating a method for updating a server certificate and an application when a problem with the root key is detected, according to one embodiment of the present disclosure.

[0117] In the following embodiments, each operation may be performed sequentially, but is not necessarily performed sequentially. For example, the order of each operation may be changed, and at least two operations may be performed in parallel.

[0118] The app management server (100) can detect problems that have occurred in the root key (including the root public key and the root private key) (710). Specifically, the app management server (100) can detect that problems have occurred in the root key due to reasons such as the possibility of exposure of the root key, compromise of integrity, breach of the key management system, or violation of the key usage policy.

[0119] The app management server (100) can generate a new root key (new root public key and new root private key) (720). That is, the app management server (100) can generate a new root key to replace the existing root key, and at this time, the new root private key is stored / managed in a secure environment of the app management server (100) for server certificate signing, and the new root public key can be included in an application to be distributed later and used for authentication to the service server (200) of the user terminal (300).

[0120] The app management server (100) can update the application (730). That is, the app management server (100) can update the application to include a new root public key and perform distribution of the updated application. In particular, the updated application can be configured to store the new root public key and perform signature verification with the new root public key on a server certificate received from the service server (200).

[0121] The service server (200) can request certificate and application updates from the user terminal (300) (740).

[0122] The user terminal (300) can download the updated application in response to the request (750). The user terminal (300) can download and save the updated application from the app management server (100) or through the application distribution channel. As a result, the user terminal (300) is equipped with a new root public key, and subsequently, the authentication procedure for the service server (200) can be performed using the new root public key.

[0123] The app management server (100) can transmit a new server certificate to the service server (200) (760). Here, the new server certificate may be signed by a new root private key. The user terminal (300) verifies the signature of the new server certificate using the new root public key stored in the updated application, and only if the verification is successful can it perform encrypted communication at the application layer using the server public key included in the server certificate.

[0125] Although various embodiments have been described above, each embodiment is not necessarily implemented individually, and may be combined with at least one other embodiment, either wholly or partially, to be implemented together in a single product.

[0126] Various embodiments of the present disclosure may be implemented as software comprising instructions stored on a machine-readable storage media that is readable by a machine (e.g., a computer). The machine may include a device (100, 200, 300) according to the disclosed embodiments, which is capable of calling instructions stored from the storage media and operating according to the called instructions. For example, a non-transient readable storage media may be provided that stores software for sequentially performing various steps as illustrated in FIG. 5 or FIG. 7.

[0127] A device equipped with such a non-transient readable medium can perform operations such as public key generation, encryption, and decryption as described in the various embodiments described above.

[0128] In non-transitory readable storage media, 'non-transitory' simply means that the storage medium does not contain a signal and is tangible; it does not distinguish whether data is stored semi-permanently or temporarily on the storage medium.

[0129] Alternatively, a program for performing the methods according to the various embodiments described above may be distributed online through an application store. For online distribution, at least a portion of the computer program product may be temporarily stored or temporarily created in a storage medium such as the memory of a manufacturer's server, an application store's server, or a relay server.

[0130] Each component (e.g., module or program) according to various embodiments may be composed of a singular or multiple entities, and some of the aforementioned sub-components may be omitted, or other sub-components may be additionally included in various embodiments. Generally or additionally, some components (e.g., module or program) may be integrated into a single entity to perform the functions performed by each of the respective components prior to integration in the same or similar manner. The operations performed by the module, program, or other components according to various embodiments may be executed sequentially, in parallel, iteratively, or heuristically, or at least some operations may be executed in a different order, omitted, or other operations added.

[0131] Although the present invention has been described above with reference to the attached drawings, the scope of the present invention is determined by the claims set forth below and should not be interpreted as being limited to the aforementioned embodiments and / or drawings. Furthermore, it should be clearly understood that improvements, changes, and modifications to the invention described in the claims that are obvious to those skilled in the art are also included within the scope of the present invention. Explanation of the symbols

[0132] 100: App Management Server 200: Service Server 300: User terminal

Claims

Claim 1 A control method for authenticating a service server in a system comprising an app management server, a user terminal, and a service server, comprising: (a) the app management server generating a root key consisting of a pair of a root public key and a root private key; (b) the app management server configuring an application to include the root public key; (c) the user terminal downloading and storing the application; (d) the service server receiving a server certificate signed with a root private key corresponding to the root public key from the app management server; (e) the service server transmitting the issued server certificate to the user terminal; (f) the user terminal performing verification of the server certificate using the root public key stored in the application; and (g) if the signature verification is successful, the user terminal performing encrypted communication at the application layer using the server public key included in the server certificate. Claim 2 A control method comprising: when an event to revoke the server certificate occurs by the service server, the service server requests the app management server to replace the server certificate; the app management server records information regarding the server certificate in a certificate revocation list; the service server receives a new server certificate signed with a root private key corresponding to the root public key from the app management server; the app management server updates the application based on the certificate revocation list; and the user terminal downloads the updated application. Claim 3 A control method according to paragraph 2, wherein the user terminal does not verify server certificates that have expired based on a certificate revocation list included in the updated application. Claim 4 In paragraph 2, the app management server controls the deletion of expired revoked certificates from the certificate revocation list during the next update. Claim 5 A control method according to claim 1, wherein when an event to replace the root key occurs, the app management server generates a new root key consisting of a pair of a new root public key and a new root private key; and the app management server updates an application to include the new root public key; wherein a server certificate signed with the root public key is excluded from the trusted object. Claim 6 A control method according to claim 1, wherein step (f) comprises the step of the user terminal additionally verifying the server identification information and validity period included in the server certificate along with the signature verification of the server certificate. Claim 7 A control method according to claim 1, wherein the encrypted communication performed in step (g) includes an electronic envelope method that encrypts data using a symmetric key encryption algorithm and encrypts the symmetric key with the server's public key and transmits it. Claim 8 In claim 1, the above step (b) is a control method for configuring the application such that the root public key is included in the form that cannot be tampered with. Claim 9 A system comprising an app management server, a user terminal, and a service server, wherein the app management server generates a root key consisting of a pair of a root public key and a root private key and configures an application to include the root public key; the user terminal downloads and stores the application and performs signature verification on a server certificate received from the service server using the root public key stored in the application; the service server is configured to receive a server certificate signed with a root private key corresponding to the root public key from the app management server and transmit it to the user terminal; and the user terminal performs encrypted communication at the application layer using the server public key included in the server certificate when the signature verification is successful. Claim 10 In claim 9, when an event to revoke the server certificate occurs by the service server, the service server requests the app management server to replace the server certificate, the app management server records information regarding the server certificate in a certificate revocation list and updates the application based on the certificate revocation list, the service server receives a new server certificate signed with a root private key corresponding to the root public key from the app management server, and the user terminal downloads the updated application. Claim 11 A system according to claim 10, wherein the user terminal does not verify server certificates that have expired based on a certificate revocation list included in the updated application. Claim 12 In Clause 10, the above-mentioned app management server is a system that deletes expired revoked certificates from the certificate revocation list at the next update. Claim 13 In claim 9, when an event to replace the root key occurs, the app management server generates a new root key consisting of a pair of a new root public key and a new root private key, the app management server updates the application to include the new root public key, and the system excludes the server certificate signed with the root public key from the trusted target. Claim 14 In claim 9, the user terminal is a system configured to additionally verify the server identification information and validity period included in the server certificate, along with the signature verification of the server certificate. Claim 15 In claim 9, the encrypted communication at the application layer includes a system comprising an electronic envelope method that encrypts data using a symmetric key encryption algorithm and encrypts the symmetric key with the server's public key to transmit it. Claim 16 In paragraph 9, the application is a system configured such that the root public key is included in a form that cannot be tampered with. Claim 17 A computer-readable recording medium storing instructions for controlling a computer to execute a control method for authenticating a service server in a system comprising an app management server, a user terminal, and a service server, wherein the control method comprises: (a) the app management server generating a root key consisting of a pair of a root public key and a root private key; (b) the app management server configuring an application to include the root public key; (c) the user terminal downloading and storing the application; (d) the service server receiving a server certificate signed with a root private key corresponding to the root public key from the app management server; (e) the service server transmitting the issued server certificate to the user terminal; (f) the user terminal performing verification of the server certificate using the root public key stored in the application; and (g) if the signature verification is successful, the user terminal performing encrypted communication at the application layer using the server public key included in the server certificate.

Images