Secure information transmission in untrusted environments
The deployment of an authentication API and network isolation using AWS Sagemaker ensures secure access to provider applications and confidential data transmission, addressing risks in unsecure environments by protecting consumer data and provider metrics.
Patent Information
- Application Number
- JP2024529524
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2021-11-19
- Filing Date
- 2022-11-19
- Publication Date
- 2024-11-13
AI Technical Summary
The transmission of information across unsecure or semi-secure environments poses risks of data disclosure and misuse, particularly when sensitive information such as consumer data or provider's confidential data is involved, necessitating secure access control and secure transmission of usage metrics.
An authentication application programming interface (API) is deployed in the provider's environment to authorize consumer access to specific components/services while maintaining data confidentiality, using a proxy function and network isolation to protect provider data and algorithms, and secure metrics transmission is achieved through encryption and token-based authentication.
Enables secure access to provider applications without exposing consumer data, while ensuring the confidentiality and integrity of usage metrics, leveraging cloud-based secure platforms like AWS Sagemaker for network isolation and encryption.
Smart Images

Figure 2024542203000001_ABST
Abstract
Description
[Technical field]
[0001] This application claims the benefit of U.S. Provisional Patent Application No. 63 / 281,420, filed November 19, 2021. The above applications are incorporated herein by reference in their entireties. [Background technology]
[0002] It is common that various types of information (including intellectual property, data, and / or algorithms) may need to be transmitted across computer networks to insecure or semi-secure environments. One example of this situation is when consumer information is transmitted across a network from an application accessed by the consumer to an application provider. This transmission of information poses the potential risk of data disclosure or misuse of the information by bad actors. The risk is greater when the information being transmitted contains either the provider's confidential data or the customer's personally identifiable information (PII) or other forms of classified information, and when the application provider does not follow standard best practices to protect that information.
[0003] A related issue is that rather than allowing a consumer to have unlimited and / or unrestricted access to an application, the consumer or others using the application may need to be properly authorized to access certain components / services within the application, which may be necessary to protect the application provider's data, algorithms, and / or intellectual property.
[0004] Another related issue is that application providers may require metrics from consumers or other users' usage of the application. These metrics need to be transmitted in a manner that is secure despite the fact that the information may traverse insecure networks and / or environments. Summary of the Invention
[0005] The present invention is directed to a system and method whereby an application provider may deploy the application provider's application directly into a consumer's environment and simultaneously allow the consumer to use the provider's application without the consumer having to share the consumer's data. Because the data never leaves the consumer's environment, there is no risk that the data will be exposed or misused by bad actors.
[0006] To provide consumers with permission to access specific components or services within the provider application while simultaneously protecting other parts of the application to protect provider data, algorithms, and intellectual property, an authentication application programming interface (API) is created in the provider environment. The API authorizes consumers through tokens to enable access to specific components and / or services of the provider's application according to the provider's preferences and the consumer's needs.
[0007] To provide metrics about customer usage to the provider, the application transfers the metrics from the application hosted within the consumer's network-isolated environment to the provider's environment, while at the same time maintaining the confidentiality and integrity of the metrics data being transported.
[0008] In some embodiments of the invention, a customer, client, subscriber, or other user of the application installs the application product in their cloud environment, such as Amazon AWS. This is typically done by setting up the necessary infrastructure in their cloud environment. The setup and installation may be done through an automated infrastructure setup service, such as AWS Cloudformation. The provider may provide a configuration template that the customer will use in their Cloudformation service. The configuration template may create three main services, in some embodiments, along with other resources. The first is an API Gateway, which is a customer-facing API with two main endpoints, INIT and REQUEST. The second is a proxy function, which may be an AWS Lambda function that sends out tokens and acts as an intermediary between the customer's installed application and the provider. The third is an embedded transcoder, which in some implementations is a proprietary application from the provider that may be hosted in AWS Sagemaker through network isolation. AWS Sagemaker is a cloud-based secure platform that enables developers to create, train, and deploy machine learning models and other facilities in the cloud, although products from other providers may be used in alternative embodiments.
[0009] In some embodiments, the present invention may be characterized by three key components. The first component is a generic authentication appliance system (GAAS). This system includes an authentication API that authorizes client applications to access provider applications that process customer data. It also provides specific permissions to these client applications, thereby allowing customers to access only those components / services that the provider wants to be accessed by the customer. The second component is a confidential compute environment. Big cloud providers like AWS provide network-isolated environments (such as AWS Sagemaker) in which providers can deploy proprietary applications. Because the environment is network-isolated, no one can access and download the data or source code of the applications hosted in this environment, but can use it in a manner approved and controlled by the application provider. The provider may then package its proprietary source code, algorithms, and / or intellectual property as a container and deploy the container in the confidential compute environment. The third component is a proxy application. The proxy application acts as an intermediary between the provider's hosted application in the customer's network isolated environment and the GAAS hosted in the provider's environment. The proxy application has two main purposes. One purpose is to submit API requests to the provider's GAAS API with credentials and receive an authentication token. The other purpose is to use the authentication token along with the client's input data to call the provider's application (hosted in the network isolated environment), which processes the client's input data and renders the results.
[0010] These and other features, objects and advantages of the present invention will become better understood from a consideration of the following detailed description of the preferred embodiments, taken in conjunction with the drawings, and the appended claims, as set forth below. [Brief description of the drawings]
[0011] [Figure 1] FIG. 2 is an overall system architecture diagram according to a preferred embodiment of the present invention. [Diagram 2] FIG. 2 is a swim lane diagram for an initialization procedure in accordance with a preferred embodiment of the present invention. [Diagram 3] FIG. 2 is a swim lane diagram for a request procedure in accordance with a preferred embodiment of the present invention. [Figure 4] FIG. 2 is a swim lane diagram for a request (refresh) procedure in accordance with a preferred embodiment of the present invention. [Diagram 5] FIG. 2 is a swim lane diagram for a metrics retrieval procedure in accordance with a preferred embodiment of the present invention. [Figure 6] FIG. 1 is a swim lane diagram for the operation of a Generic Authentication Appliance System (GAAS) in accordance with a preferred embodiment of the present invention. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0012] Before the present invention is described in greater detail, it is to be understood that the invention is not limited to the particular embodiments described, and that the terminology used in describing the particular embodiments is for the purpose of describing those particular embodiments only, and is not limiting, since the scope of the invention is limited only by the claims.
[0013] With reference now to FIG. 1, an environment for one embodiment of the present invention may now be described. A customer / client application 10 resides in a customer cloud environment 11. This application may be used for various computing purposes, such as processing customer data stored in the customer cloud environment 11 and dispatched by the provider. A Generic Authentication Appliance System (GAAS) 12 includes an API gateway that allows authorization of the client application 10 to access various features. It allows specific permissions for the client application 10, thereby allowing the customer to access only those components and services approved by the provider for use by that customer. A proxy function / application 14 acts as an intermediary between the client application 10 in the customer cloud environment 11 and the GAAS 12 in the provider cloud environment 13. The proxy function 14 may submit API requests with credentials to the GAAS 12 and receive authentication tokens from the GAAS 12 along the network path shown in FIG. 1. The proxy function 14 may then use the authentication token along with the client's input data to call the embedded transcoder 16 (hosted in a network isolated environment in the customer cloud environment 11) to process the client's data and render the results. The container 19 securely stores private provider data, algorithms and / or intellectual property within the customer cloud environment 11, thereby preventing unrestricted access by the client application 10. The IDAPI 18 serves as the source of truth in the system, as described below.
[0014] 6, the role of GAAS 12 (General Authentication Appliance System) and how keys are generated for the system can now be described. The embedded transcoder 16 is packaged with three different types of keys: a decryption key, i.e., a public Rivest-Shamir-Adleman (RSA) key generated using openssl; application_pub_key, i.e., a public RSA key generated using openssl; and application_pem_key, i.e., a private RSA key corresponding to application_pub_key. At the same time, SMAuth (i.e., GAAS 12 in the AWS environment) is updated to store the same application_pub_key (packaged inside the embedded transcoder 16) in its secret manager 30 and an encode_key, which is a public RSA key corresponding to the decryption key packaged inside the embedded transcoder 16.
[0015] When the embedded transcoder 16 is installed and running in the consumer cloud environment in step 6A, the embedded transcoder 16 generates a key pair called appliance_pub_key (public RSA key) and appliance_pem_key (private RSA key) at startup in step 6B and stores the keys in memory. When the client application 10 sends an INIT request to the SM Proxy 14 in step 6C, it performs three consecutive actions. First, it sends a request to the embedded transcoder 16 with the rpc value as init_keys in step 6D. Upon receiving this request, the embedded transcoder 16 creates a JSON response called appliance_response in step 6E, which contains two keys: the appliance_pub_key signed by the application_pem_key called appliance token, and the application_pub_key. Once this response is received by the SM Proxy 14, the second action begins by calling the init endpoint of GAAS 12 in step 6F. GAAS 12 receives the request for verification and returns an INIT token. It then reads the application_pub_key in the request and verifies whether the application_pub_key exists in its secret manager 30. If the existence of the application_pub_key is verified, GAAS then verifies the signature of the appliance token with its application_public_key in step 6G. If the signature is verified, it then stores the appliance_pub_key in its secret manager 30 in step 6H. Hereafter, GAAS uses the appliance_pub_key as a public key, also called encryption key, to encrypt the secret data, and further uses the pre-configured private key, also called encryption key, to encode / sign the data.In the embedded transcoder 16, the corresponding keys are the appliance_pem_key, which is used as a private key, also called a decryption key, to decrypt the secret data, and a pre-configured public key, also called a decode_key, to decode or verify the signature of the encoded data. The third action of the INIT flow is described below.
[0016] To set up the customer cloud environment 11, the customer may use an automated infrastructure setup service, such as AWS Cloudformation. The provider may use configuration templates to build the proxy function 14 component and the embedded transcoder 16 component, as described further below.
[0017] The process for enabling the use of data, algorithms, or intellectual property by the client application 10 may then continue and begin with an INIT flow as shown with reference to the swim lane diagram of FIG. 2. The embedded transcoder 16 contains a public key called a decryption key with a corresponding private key called an encoding key in GAAS 12. The embedded transcoder 16 also contains a private key called a decryption key with a corresponding public key called an encryption key in GAAS 12. To initiate the application of the embedded transcoder 16 for use, the customer application 10 calls the INIT endpoint of the API gateway of the proxy function 14 with the customer certificate in step 2A. The API gateway calls the proxy function 14, which calls the GAAS 12 in the provider cloud environment 13 to generate an INIT token in step 2B. The INIT token contains the private key data that will be used for the embedded transcoder 16 to operate. To generate this INIT token, GAAS 12 first verifies the customer application 10's attestation against the backend system IDAPI 18 in step 2C. GAAS 12 retrieves the private key data from IDAPI 18 in step 2D when this system is the "source of truth" for the provider. GAAS 12 then subsequently creates a JSON web token called the INIT token using the private key data from IDAPI 18 in step 2E. The INIT token is sent to the proxy 14 in step 2F.
[0018] The private key data in the INIT token needs to be kept confidential, so GAAS 12 generates a random session key internally by encrypting it with its RSA public key, and then encrypts the private data with the encrypted session key using the AES (Advanced Encryption Standard) specification to generate a ciphertext. GAAS 12 also ensures the integrity of the data by signing the INIT token with a private encoding key. In step 2G, the INIT token is sent to the embedded transcoder 16. When this INIT token is received by the embedded transcoder 16, it decrypts the token with its public decryption key to verify the source. Once the source is verified, it then decrypts the encrypted session key with its RSA private decryption key, and then uses the decrypted session key to decrypt the ciphertext generated by GAAS 12 using the AES (Advanced Encryption Standard) specification, and stores this data in the machine it is hosted in the customer cloud environment 11. Since the machine hosting the application is network isolated, there is no possibility of the private key data being leaked.
[0019] After the embedded transcoder 16 application completes the process of saving the private key data, it subsequently sends an acknowledgement to the proxy function 14 in step 2H. The proxy function 14 then sends a success response to the customer application 10 in step 2I. Throughout this process, if any of the validations fail due to either invalid / incorrect information in either the GAAS 12 or the embedded transcoder 16, the customer application 10 receives an error message stating that validation failed. Once the initialization is complete, the customer application 10 receives a response, also in step 2I, that includes the success acknowledgement along with another JSON web token called a SMART token. The initialization is valid for 24 hours, and the client needs to reinitialize afterwards because the embedded transcoder 16 invalidates the private data at the end of the 24 hours.
[0020] The process for the REQUEST flow can be described with reference to the swim lane diagram of FIG. 3, which shows a REQUEST process that in one embodiment is repeated every 15 minutes for improved security. The SMART token consists of the access specific details of the customer application 10 that the embedded transcoder 16 needs to process the customer input data. The customer application 10 calls the proxy function 14 with its input data and the SMART token as input parameters in step 3A. The proxy function then calls the embedded transcoder 16 in a protected environment within the customer cloud environment 11 to accept the request in step 3B. The embedded transcoder 16 then subsequently performs a verification with its key to verify the SMART token in step 3C. Once verified, it processes the input data and returns the result in step 3D to the proxy function 14, which returns it to the customer application 10 in step 3E.
[0021] In the above REQUEST process, if any of the validations fail due to invalid / incorrect information in the embedded transcoder 16, the customer application 10 will receive an error message stating that validation failed. Since the SMART token is valid only for a limited period of time, such as 15 minutes, the customer application 10 will refresh the token using the same proxy function 14, which will send an authentication request to GAAS 12, which will render a fresh token after validation for each refresh request.
[0022] A refresh process may be performed periodically, such as every 15 minutes, while the SMART token is in use. This refresh process may be described with reference to the swim lane diagram of FIG. 4. When a refresh is needed, the client application 10 sends a request to the proxy function 14 in step 4A. In step 4B, the proxy function 14 passes the refresh request to GAAS 12 (also called SM Auth in the AWS environment example). Then, in step 4C, GAAS 12, as the source of truth in the system, sends a request for a new token to the IDAPI 18. In step 4D, the IDAPI 18 responds to GAAS 12 with a return token (or an error if no token can be returned). GAAS 12 then returns the new (refreshed) SMART token in step 4E to the proxy function 14, which passes the new SMART token on to the client application 10 in step 4F.
[0023] Usage metrics data may be generated and stored as shown with reference to the swim lane diagram of FIG. 5. A scheduler 20 (such as the AWS scheduler) may initiate the process with a call to the proxy function 14 in step 5A. In step 5B, a request is made from the proxy function 14 to the embedded transcoder 16. Metrics generated in the embedded transcoder 16 are encrypted with the embedded transcoder 16's public key and signed with its private key. The embedded transcoder 16 then packages all of this data into a JSON web token called a metrics token and returns it when polled periodically by the proxy function 14 in step 5C. The proxy function 14 then transports the metrics token in step 5D to GAAS 12, which decrypts it using the corresponding public key and then decrypts it using the corresponding private key to read the usage metrics data. This metrics data is written to Datadog 22, an external logging service, which may return an acknowledgment in step 5E, which is then passed from GAAS 12 to proxy function 14 in step 5F.
[0024] Next, the proxy function 14 (sometimes referred to as the SageMaker or SM proxy function in the context of the AWS cloud environment) can be described in more detail. The proxy function 14 has two functions: request_auth and init_auth. The request_auth function basically receives an input request from a client service, which typically contains the following parameters: smart_token - used for authentication transcode_data - contains the transcode data input rpc--indicates whether it is an init, request, or refresh.
[0025] The proxy function 14 performs the following verifications before performing the actual operation. First, it verifies whether smart_token is present in the input request body. Second, it verifies whether transcode_data is present in the input request body. Third, it verifies whether rpc is present in the input request body and its value is either request or refresh. If any of these verifications fail, it sends an appropriate error response to the client.
[0026] The request_auth execution steps when rpc is set to refresh are as follows: First, request_auth validates the input request body to read the client id and client secret. It then calls GAAS12 (also known as SM Auth Request Service in AWS cloud environment) and passes those credentials to receive a new smart_token. Next, it validates the token for signature and expiration. In case of invalid or expired, it returns an appropriate error response to the client. It then sends the smart_token back to the client service.
[0027] An example curl request for request_auth in this case might be as follows:
number
[0028] The request_auth execution steps when rpc is set in the request are as follows: First, request_auth reads the input request body for smart_token and transcode_data. It then validates the token for signature and expiration. If invalid or expired, it returns an appropriate error response to the client. If the token is valid, it calls the SageMaker endpoint with the transcode data and smart token. It then receives the transcoded link from SageMaker and sends the response back to the client.
[0029] An example curl request for request_auth in this case might be as follows:
number
[0030] The init_auth function basically fetches the domain keys from GAAS 12 and passes them to the embedded transcoder 16 to be retained for 24 hours. It receives an input request from the client service, which typically contains the following parameters: client_id - used for authentication. Contains the client_secret - transcoding data input. rpc - indicates whether it is an init, request or refresh.
[0031] The init_auth function performs the following verifications before performing the actual operation. First, it verifies whether client_id is present in the input request body. Then, it verifies whether client_secret is present in the input request body. Next, it verifies whether rpc is present in the input request body and its value is init. If any of these verifications fail, it sends an appropriate error response to the client.
[0032] The steps of init_auth execution when rpc is set to init are as follows: First, it calls GAAS12 with the client certificate. Then, it validates the token for signature and expiration. If invalid or expired, it returns an appropriate error response to the client. If the token is valid, it calls the SageMaker endpoint, passes the INIT token, and receives a response indicating the status of transcoding initialization. Then, it extracts the smart_token from the INIT token, and then sends the smart_token and the initialization response status back to the client.
[0033] An example curl request for init_auth in this case might be:
number
[0034] Next, GAAS12 (also called SM Auth in the AWS environment) can be explained in more detail.
[0035] GAAS 12 has three functions deployed: auth_token, init_token, and push_metrics. When the auth_token function is called by the proxy function 14 in the customer cloud environment 11, it performs the following operations. First, it reads the input from the proxy function 14 auth request for the client credentials and the appliance response (e.g., appliance token and application pub key). It then calls the IDAPI 18 token endpoint with those credentials to fetch the IDAPI authentication token. Next, it uses the IDAPI authentication token to call the / domains endpoint to fetch the domain keys required for transcoding. It then creates a scopes object that indicates the transcoding direction for the domain. Finally, it wraps the IDAPI token and SCOPES with an expiration timestamp and encodes the data to generate a JWT token called SMART TOKEN (aka sagemakerRequestToken).
[0036] An example curl request for the auth_token in this case might be:
number
[0037] An example smart token response may be as follows:
number
[0038] An exemplary smart token response that is decoded may be as follows:
number
[0039] The init_token function performs the following operations when called by the proxy function 14 in the customer cloud environment 11. It performs two more steps compared to the auth function. It reads the input from the proxy function 14 init request for the client credentials. It then calls the IDAPI 18 / token endpoint with those credentials to fetch the IDAPI authentication token. It then calls the / domains endpoint with the IDAPI 18 authentication token to fetch the domain keys needed for transcoding. It then creates a scopes object that indicates the transcoding direction for the domain. It then wraps the IDAPI 18 token and SCOPES with an expiration timestamp and encodes the data to generate a JWT token called SMART TOKEN. Furthermore, it then encrypts the domain keys and generates the ciphertext, session keys, and initialization vectors (IVs) to securely transfer them to the embedded transcoder 16 via the proxy function 14. Finally, it wraps the SMART TOKEN (sagemakerRequestToken), CIPHER TEXT (encryptedKeyPacket), SESSION KEY (encSessionkey), and IV, and encodes the data to generate a JWT token called INIT TOKEN.
[0040] An example curl request for the init_token in this case might be:
number
[0041] The INIT token has the following format: " <header> . <payload> . <signature>" Here, HEADER specifies the type and algorithm used for the JWT, PAYLOAD is the token content, and SIGNATURE is a standard JWT signature. In this case, it uses jwt as the type and RS256 as the signature type.
[0042] The INIT token contains the very important concept of PUBLIC and PRIVATE space within the PAYLOAD section.
[0043] Data in the PRIVATE section may only be accessed by having the correct private key to initiate the decryption of the session key and therefore the decryption of the PRIVATE section (encryptedKeyPacket). Only trusted systems or individuals will have this private key, which proves ownership of the data.
[0044] PRIVATE space is any data contained within the encryptedKeyPacket(CIPHERTEXT) and may include, but is not limited to, sensitive data, intellectual property, application data, application logic, secrets, keys, authentication claims, scopes, or any other data that must be protected and can be binary encoded. PRIVATE space also includes the IV and encSessionKey.
[0045] Data in the PUBLIC space will be public and viewable by anyone or anything that consumes or views the token. The data has authority over it because it was added to the token by the authentication endpoint and signed with the auth endpoint's private key. The authority can be verified using standard JWT practices. This PUBLIC space data cannot be modified and therefore can be trusted to be true if signature verification can be confirmed. Parties can access and use data in this payload's public space. Items that are not in the encryptedKeyPacket, encSessionKey, or iv are considered part of the public space. Elsewhere in this document, SMART tokens (sagemakerRequestToken) are part of the public space, including but not limited to them. The PUBLIC space is available to any type of data included in the payload that is not in the PRIVATE space.
[0046] An exemplary INIT token response may be as follows:
number
[0047] An exemplary decoded INIT token response (PAYLOAD) may be as follows:
number
[0048] The push_metrics function, when called by the proxy function 14, performs the following operations: First, it reads input from the proxy function 14 push metrics request. It then decrypts the metrics token using the appliance pub key. It then sends the embedded transcoder 16 metrics to Datadog.
[0049] An example curl request for push_metrics in this case might be as follows:
number
[0050] Exemplary metric tokens may be as follows:
number
[0051] An example metrics token to be decoded may be as follows:
number
[0052] The systems and methods described herein may be implemented by any combination of hardware and software in various embodiments. For example, in one embodiment, the systems and methods may be implemented by a computer system or collection of computer systems, each of which includes one or more processors that execute program instructions stored on a computer-readable storage medium coupled to the processor. The program instructions may implement the functionality described herein. The various systems and displays described herein, as illustrated in the figures, represent example implementations. The order of any method may be changed, and various elements may be added, modified, or omitted.
[0053] The computing system or computing device described herein may implement the hardware portion of a cloud computing system or a non-cloud computing system as forming part of various implementations of the present invention. The computing system may be any of a variety of types of devices, including, but not limited to, a commodity server, a personal computer system, a desktop computer, a laptop or notebook computer, a mainframe computer system, a handheld computer, a workstation, a network computer, a consumer device, an application server, a storage device, a telephone, a mobile phone, or generally any type of computing node, compute node, compute device, and / or computing device. The computing system includes one or more processors (which may include multiple processing cores, any of which may be single or multi-threaded) coupled to a system memory via an input / output (I / O) interface. The computing system may further include a network interface coupled to the I / O interface.
[0054] In various embodiments, the computer system may be a single processor system including one processor, or a multiprocessor system including multiple processors. The processor may be any suitable processor capable of executing computing instructions. For example, in various embodiments, the processor may be a general purpose processor or an embedded processor implementing any of a variety of instruction set architectures. In a multiprocessor system, each of the processors may typically, but not necessarily, implement the same instruction set. The computer system also includes one or more network communication devices (e.g., network interfaces) for communicating with other systems and / or components across a communications network, such as a local area network, a wide area network, or the Internet. For example, a client application executing on a computing device may use the network interface to communicate with a server application executing on a single server or on a cluster of servers implementing one or more of the components of the system described herein in a cloud computing or non-cloud computing environment implemented in various subsystems. In another example, an instance of a server application executing on a computer system may use the network interface to communicate with other instances of the application that may be implemented on other computer systems.
[0055] The computing device also includes one or more persistent storage devices and / or one or more I / O devices. In various embodiments, the persistent storage device may correspond to a disk drive, a tape drive, solid-state memory, other mass storage device, or any other persistent storage device. A computer system (or a distributed application or operating system running thereon) may store instructions and / or data in the persistent storage device as desired and may retrieve the stored instructions and / or data as needed. For example, in some embodiments, a computer system may implement one or more nodes of a control plane or control system, and the persistent storage may include SSDs attached to the server nodes. Multiple computer systems may share the same persistent storage device or may share a pool of persistent storage devices, where the devices in the pool represent the same or different storage technologies.
[0056] A computer system includes one or more system memories that may store code / instructions and data accessible by the processor(s). The memory capabilities of a system may include, for example, multiple levels of memory and memory caches in systems designed to swap information in memory based on access speed. Interleaving and swapping may extend to persistent storage in virtual memory implementations. Technologies used to implement memory may include, by way of example, static random-access memory (RAM), dynamic RAM, read-only memory (ROM), non-volatile memory, or flash-type memory. As with persistent storage, multiple computer systems may share the same system memory or may share a pool of system memory. The system memory or memories may include program instructions executable by the processor(s) to implement the routines described herein. In various embodiments, the program instructions may be encoded in binary, assembly language, any interpreted language such as Java, a compiled language such as C / C++, or any combination thereof, and the particular languages given herein are merely illustrative. In some embodiments, the program instructions may implement multiple separate client, server nodes, and / or other components.
[0057] In some implementations, the program instructions may include instructions executable to implement an operating system (not shown), which may be any of a variety of operating systems, such as UNIX, LINUX, Solaris, MacOS, or Microsoft Windows. Any or all of the program instructions may be provided as a computer program product or software, which may include a non-transitory computer-readable storage medium having stored thereon instructions that may be used to program a computer system (or other electronic device) to perform a process according to various implementations. A non-transitory computer-readable storage medium may include any mechanism for storing information in a form (e.g., software, processing application) readable by a machine (e.g., a computer). In general, a non-transitory computer-accessible medium may include a computer-readable storage medium or memory medium, such as a magnetic medium or an optical medium, e.g., a disk or DVD / CD-ROM coupled to a computer system via an I / O interface. A non-transitory computer-readable storage medium may include any volatile or non-volatile medium, such as RAM or ROM, that may be included as system memory or another type of memory in some embodiments of a computer system. In other implementations, program instructions may be communicated using optical, acoustic, or other forms of propagated signals (e.g., carrier waves, infrared signals, digital signals, etc.) transmitted over a communications medium, such as a network and / or wired or wireless link, such as may be implemented via a network interface. A network interface may be used to interface with other devices, which may include other computer systems or any type of external electronic device.Generally, system memory, persistent storage, and / or remote storage accessible on other devices through a network may store data blocks, replicas of data blocks, metadata associated with the data blocks and / or their state, database configuration information, and / or any other information usable in implementing the routines described herein.
[0058] In some implementations, the I / O interface may coordinate I / O traffic between the processor, system memory, and any peripheral devices in the system, including through a network interface or other peripheral interface. In some embodiments, the I / O interface may perform any necessary protocol, timing, or other data conversion to convert data signals from one component (e.g., system memory) into a format suitable for use by another component (e.g., processor). In some embodiments, the I / O interface may include support for devices attached through various types of peripheral buses, such as, for example, variations on the Peripheral Component Interconnect (PCI) bus standard or the Universal Serial Bus (USB) standard. Also, in some embodiments, some or all of the functionality of the I / O interface, such as an interface to the system memory, may be incorporated directly into the processor(s).
[0059] The network interface may, for example, allow data to be exchanged between the computer system and other devices attached to the network, such as other computer systems (which may implement one or more storage system server nodes, primary nodes, read-only nodes, and / or database system clients as described herein). Additionally, the I / O interface may allow communication between the computer system and various I / O devices and / or remote storage. The I / O devices may, in some embodiments, include one or more display terminals, keyboards, keypads, touchpads, scanning devices, voice or light recognition devices, or any other device suitable for entering or retrieving data by one or more computer systems. These may be directly connected to a particular computer system or may generally connect to multiple computer systems in a cloud computing environment, grid computing environment, or other system involving multiple computer systems. Multiple I / O devices may be in communication with the computer system or may be distributed on various nodes of a distributed system that includes the computer system. The user interfaces described herein may be visible to a user using various types of display screens, which may include CRT displays, LCD displays, LED displays, and other display technologies. In some implementations, input may be received through a display using touch screen technology, while in other implementations, input may be received through a keyboard, mouse, touchpad, or other input technology, or any combination of these technologies.
[0060] In some embodiments, similar input / output devices may be separate from the computer system and may interact with one or more nodes of a distributed system that includes the computer system through a wired or wireless connection, such as over a network interface. The network interface may typically support one or more wireless networking protocols (e.g., Wi-Fi / IEEE 802.11, or another wireless networking standard). The network interface may support communication over any suitable wired or wireless general data network, such as, for example, other types of Ethernet networks. Additionally, the network interface may support communication over a telecommunications / telephony network, such as an analog voice network or a digital fiber communications network, communication over a storage area network, such as a Fibre Channel SAN, or communication over any other suitable type of network and / or protocol.
[0061] Any of the distributed system embodiments described herein, or any of their components, may be implemented as one or more network-based services in a cloud computing environment. For example, read-write and / or read-only nodes in a database tier of a database system may present database services and / or other types of data storage services employing the distributed storage system described herein to clients as network-based services. In some embodiments, the network-based services may be implemented by software and / or hardware systems designed to support interoperable machine-to-machine interaction over a network. A web service may have an interface described in a machine-processable format, such as Web Services Description Language (WSDL). Other systems may interact with the network-based service in a manner prescribed by the description of the network-based service's interface. For example, the network-based service may define various operations that other systems may invoke and may define specific application programming interfaces (APIs) that other systems may be expected to follow when requesting the various operations.
[0062] In various embodiments, a network-based service may be requested or invoked through the use of a message that includes parameters and / or data associated with a network-based service request. Such a message may be formatted according to a particular markup language, such as Extensible Markup Language (XML), and / or may be encapsulated using a protocol, such as Simple Object Access Protocol (SOAP). To perform a network-based service request, a network-based service client may assemble a message that includes the request and communicate the message using an Internet-based application layer transport protocol, such as Hypertext Transfer Protocol (HTTP), to an addressable endpoint (e.g., a Uniform Resource Locator (URL)) that corresponds to the web service. In some embodiments, a network-based service may be implemented using Representational State Transfer (REST) techniques rather than message-based techniques. For example, a network-based service implemented according to REST techniques may be invoked through parameters included within an HTTP method, such as PUT, GET, or DELETE.
[0063] Unless otherwise specified, all technical and scientific terms used herein have the same meaning as commonly understood by those skilled in the art to which this invention belongs. Although methods and materials similar or equivalent to those described herein can also be used in the practice or testing of the present invention, a limited number of exemplary methods and materials are described herein. It will be apparent to those skilled in the art that many more modifications are possible without departing from the inventive concepts herein.
[0064] All terms used herein should be interpreted in the broadest possible manner consistent with the context. When groupings are used herein, all individual members of the group and all possible combinations and subcombinations of the group are intended to be included individually. When ranges are stated herein, the ranges are intended to include all subranges and individual points within the range. All references cited herein are incorporated herein by reference to the extent that they are not inconsistent with the present disclosure of this specification.
[0065] The present invention has been described in terms of certain preferred and alternative embodiments, which are intended to be examples only and not limiting of the full scope of the invention as set forth in the appended claims.< / signature> < / payload> < / header>
Claims
1. 1. A method for securely transmitting information in an untrusted environment, comprising: The method steps of generating an appliance public key and an appliance private key in an embedded transcoder hosted in a consumer cloud environment; a method step of sending, at a client application hosted in the consumer cloud environment, a set of customer credentials and an INIT request to a proxy function hosted within the consumer cloud environment; The method steps of requesting, at a proxy function, an application public key and an appliance token including an appliance identifier (appliance ID) and the appliance public key from the embedded transcoder; a method step in the embedded transcoder of responding to the proxy function; a method step of requesting authorization and an INIT packet from a Generic Authentication Appliance System (GAAS) in the proxy function and sending the application public key and an appliance token to the GAAS; a method step in the GAAS of verifying the application public key and returning an INIT token to the proxy function, the INIT token including a payload including a public section and a private section; a method step of sending, in the proxy function, the INIT token to the embedded transcoder; the method steps of verifying, in the embedded transcoder, a signature on the INIT token using a decryption key; a method step of sending a transcoding request to the embedded transcoder in the proxy function; a method step of receiving a transcoding request and returning a result in the embedded transcoder; a method step of validating a response from the embedded transcoder in the proxy function and returning the response to the client application; A method comprising:
2. 2. The method of claim 1, wherein the appliance public key is signed by an application private key in the embedded transcoder and sent along with an application public key to the proxy function, which forwards the signed appliance public key and the application public key to the GAAS.
3. 3. The method of claim 2, wherein the step of verifying the application public key comprises the step of calling a private manager from the GAAS and verifying whether the application public key exists in the private manager.
4. 4. The method of claim 3, further comprising the step of extracting the appliance public key from within the appliance token after the GAAS verifies the appliance token with an application public key of the GAAS, and then storing the appliance public key in the private manager.
5. 5. The method of claim 4, wherein the private section of the INIT token is encrypted with a private key.
6. The method of claim 5 , wherein the INIT token contains secret data for use by the embedded transcoder.
7. 7. The method of claim 6, further comprising the step of verifying the set of customer credentials at the IDAPI by extracting secret data from the IDAPI at the GAAS before returning an INIT token to the proxy function.
8. The method of claim 7 , further comprising the step of encrypting the private data at the GAAS using the appliance public key.
9. signing the INIT token at the GAAS with an encryption key and sending the INIT token to the proxy function; sending, in the proxy function, the INIT token to the embedded transcoder; verifying the INIT token with a decryption key in the embedded transcoder; after the INIT token verification is successful, the embedded transcoder enables itself to service requests; The method of claim 8 further comprising:
10. calling the proxy function from the client application with a SMART token and a set of transcode data; calling the embedded transcoder from the proxy function to verify the SMART token and receive the set of transcoded data; processing the transcoded data in the embedded transcoder and returning a set of transcoded data results to the proxy function; sending said set of transcoded data results from said proxy function to said client application; The method of claim 9 further comprising:
11. sending a refresh request from said client application to said proxy function; transferring the refresh request from the proxy function to the GAAS; sending a request from the GAAS to the IDAPI for a new IDAPI token and secret data; returning the IDAPI token and secret data from the IDAPI to the GAAS; creating a new SMART token using said IDAPI token and secret data in GAAS; sending said new SMART token from said GAAS to said proxy function; sending said new SMART token from said proxy function to said client application; The method of claim 10 further comprising:
12. generating a metrics data request within a customer's cloud environment and sending said metrics data request to said proxy function; sending the metrics data request from the proxy function to the embedded transcoder; generating a set of metrics in the embedded transcoder; embedding said set of metrics in a metric token in said embedded transcoder; encoding the metrics token with the appliance private key at the embedded transcoder and sending the metrics token to the proxy function; sending the metrics token from the proxy function to the GAAS and decrypting the metrics token at the GAAS with an appliance public key of the GAAS to recover the set of metrics; writing said set of metrics to an external logging service; The method of claim 11 further comprising:
13. 1. A system for securing information transmission in an untrusted environment, comprising: A consumer cloud computing environment; a provider cloud computing environment connected over a network to the consumer cloud computing environment; a client application hosted in the consumer cloud computing environment, the client application configured to process a set of client data; a generic authentication appliance system (GAAS) hosted in the provider cloud computing environment, the GAAS configured to control access to one or more provider applications in the consumer cloud computing environment, the GAAS further configured to generate an INIT token including an INIT header, an INIT payload, and an INIT signature, the INIT payload including a public section and a private section; an embedded transcoder in the consumer cloud computing environment, the embedded transcoder being located in a network isolated environment within the consumer cloud computing environment and the client application having restricted access; a proxy function located in the consumer cloud computing environment, the proxy function configured to pass communications between the client application and the GAAS; A system comprising:
14. 14. The system of claim 13, wherein the GAAS comprises an application programming interface (API) configured to communicate with consumer applications and provide access to provider applications hosted in the consumer cloud computing environment.
15. 15. The system of claim 14, wherein the embedded transcoder comprises a container that stores provider source code, provider algorithms, or provider intellectual property, or any combination thereof, and the network isolation environment limits access to the embedded transcoder from the client application.
16. 16. The system of claim 15, wherein the proxy application is further configured to submit an API request to the GAAS to receive an authentication token.
17. 17. The system of claim 16, wherein the proxy application is further configured to send the authentication token and the set of client data to the embedded transcoder, and in response, the embedded transcoder is further configured to process the set of client data and render a set of results.
18. 20. The system of claim 17, further comprising an IDAPI hosted in the provider cloud computing environment and in communication with the GAAS, the IDAPI configured to verify data from the GAAS as a source of truth for the system.
19. 20. The system of claim 18, wherein the embedded transcoder stores a decryption key, an application public key, and an application private key.
20. 20. The system of claim 19, further comprising a secret manager, the GAAS configured to verify the presence of the application public key in the secret manager in response to an INIT request generated by the proxy function.
Citation Information
Patent Citations
Method for establishing trust relationship between cloud services, and system
JP2012103931A
Single sign-on and single log-out function for multi-tenant identity and data security management cloud service
JP2019164794A
Optimized transport layer security
US10341302B2
Hybrid authentication systems and methods
US20190007409A1
Method and apparatus for secure token generation
US20210067341A1
