Network communication using evidence of presence

Abstract

A technique that allows two computing systems to communicate with each other with high confidence that a particular entity exists on the other computing system. As an example, when a first computing system communicates with a second computing system, the first computing system may periodically verify that a particular entity exists on the second computing system. The first computing system has actual control over a proof capture component on the second computing system. The first computing system causes the second computing system to automatically generate a proof of existence, which is evidence that proves that the particular entity exists on the second computing system. The first computing system also causes the second computing system to include the generated proof of existence when communicating from the second computing system to the first computing system.

Description

[Background technology]

[0001] The information age is made possible in large part by computing systems that communicate with each other over networks. The information exchanged can often be quite sensitive, making secure communications essential. If that information is obtained by an inappropriate party, privacy is often compromised and the information can be used for inappropriate purposes. One way to improperly obtain information is for one party to pose as a trusted party with the intent of eliciting another party to enter sensitive information (such as name, address, government identification number, credit card number, bank account information, passwords, security credentials, etc.). This is often referred to as phishing. Phishing attacks are becoming increasingly convincing, so even smart users can fall victim to a phishing attack.

[0002] The subject matter claimed herein is not limited to embodiments that solve any shortcomings or that operate only in environments such as those described above. Rather, this background is only provided to illustrate one example technology area where some embodiments described herein may be practiced. Summary of the Invention

[0003] This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended for use as an aid in determining the scope of the claimed subject matter.

[0004] The principles described herein relate to techniques that allow two computing systems to communicate with each other with high confidence that a particular entity exists in the other computing system. As an example, when a first computing system communicates with a second computing system, the first computing system may periodically verify that a particular entity exists in the second computing system.

[0005] For example, if the particular entity was a human user of the second computing system, the first computing system could periodically verify that the first computing system is communicating with the actual, trusted, particular user through the second computing system, making it much more difficult for another user to step in and pose as the particular trusted entity (and thereby illicitly extract sensitive information). On the other hand, if the particular entity was an executable component, the first computing system could periodically verify that the first computing system is communicating with an executable component that is actually running on the second computing system, making it much more difficult for another executable component to pose as the trusted executable component, since its physical presence on the second computing system is periodically verified.

[0006] According to this communication technique, a first computing system actually controls a proof capture component on a second computing system. The first computing system causes the second computing system to automatically generate a proof of existence, which is evidence that proves that a particular entity exists on the second computing system. The first computing system also causes the second computing system to include the generated proof of existence when communicating from the second computing system to the first computing system.

[0007] For each of one or more communications received from the second computing system, the first computing system reads the presence evidence from the communication and infers from the presence evidence whether a particular entity exists at the second computing system. If the inference is that the particular entity exists at the second computing system, the first computing system passes the communication, thereby treating the particular entity as existing at the second computing system. On the other hand, if the inference is not that the particular entity exists at the second computing system, the first computing system stops the communication, thereby treating the communication as not being from the particular entity.

[0008] Similarly, the second computing system may periodically verify that another specific entity is present at the first computing system. Thus, both computing systems may have a high degree of confidence that they are communicating with the intended opposing entity and not with an imposter involved in a phishing attack. The presence of a specific entity at the second computing system may also be verified when a user is physically present at a mobile device that can verify its physical presence at the network node that is actually communicating with the first computing system.

[0009] Additional features and advantages will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by the practice of the teachings herein. The features and advantages of the invention may be realized and obtained by means of the instruments and combinations particularly pointed out in the appended claims. Features of the invention will become more fully apparent from the following description and the appended claims, or may be learned by the practice of the invention as set forth hereinafter.

[0010] To illustrate the manner in which the foregoing and other advantages and features may be obtained, a more particular description of the subject matter briefly described above will be given by reference to specific embodiments which are illustrated in the accompanying drawings, in which the embodiments will be described and explained with additional specificity and detail, with the understanding that such drawings depict only exemplary embodiments and therefore should not be considered limiting in scope. [Brief description of the drawings]

[0011] [Figure 1] FIG. 1 illustrates an environment in which a first computing system uses a proof capture component on a second computing system to prove that a particular entity exists on the second computing system, according to principles described herein. [Diagram 2] 2 illustrates a flowchart of a method 200 for a first computing system to receive a communication from a second computing system according to principles described herein. [Diagram 3] 1 illustrates an example communication including presence evidence in accordance with principles described herein. [Figure 4] 2 illustrates an exemplary environment similar to FIG. 1, except that both computing systems have a proof capture component, and thus the method of FIG. 2 may be implemented bidirectionally. [Diagram 5] FIG. 1 illustrates an exemplary computing system in which the principles described herein may be employed. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0012] The principles described herein relate to techniques that allow two computing systems to communicate with each other with high confidence that a particular entity exists in the other computing system. As an example, when a first computing system communicates with a second computing system, the first computing system may periodically verify that a particular entity exists in the second computing system.

[0013] For example, if the particular entity was a human user of the second computing system, the first computing system could periodically verify that the first computing system is communicating with the actual, trusted, particular user through the second computing system, making it much more difficult for another user to step in and pose as the particular trusted entity (and thereby illicitly extract sensitive information). On the other hand, if the particular entity was an executable component, the first computing system could periodically verify that the first computing system is communicating with an executable component that is actually running on the second computing system, making it much more difficult for another executable component to pose as the trusted executable component, since its physical presence on the second computing system is periodically verified.

[0014] According to this communication technique, a first computing system actually controls a proof capture component on a second computing system. The first computing system causes the second computing system to automatically generate a proof of existence, which is evidence that proves that a particular entity exists on the second computing system. The first computing system also causes the second computing system to include the generated proof of existence when communicating from the second computing system to the first computing system.

[0015] For each of one or more communications received from the second computing system, the first computing system reads the presence evidence from the communication and infers from the presence evidence whether a particular entity exists at the second computing system. If the inference is that the particular entity exists at the second computing system, the first computing system passes the communication, thereby treating the particular entity as existing at the second computing system. On the other hand, if the inference is not that the particular entity exists at the second computing system, the first computing system stops the communication, thereby treating the communication as not being from the particular entity.

[0016] Similarly, the second computing system may periodically verify that another specific entity is present at the first computing system. Thus, both computing systems may have a high degree of confidence that they are communicating with the intended opposing entity and not with an imposter involved in a phishing attack. The presence of a specific entity at the second computing system may also be verified when a user is physically present at a mobile device that can verify its physical presence at the network node that is actually communicating with the first computing system.

[0017] First, one-way communication between computing systems is described with reference to FIG. 1. FIG. 1 illustrates an environment 100 in which a computing system 102 should communicate to another computing system 101. The computing system 101 is referred to herein as a "first computing system" and the computing system 102 is referred to herein as a "second computing system." Unless otherwise indicated, the use of modifiers such as "first," "second," and the like, is merely to distinguish one item or operation from another, and should not be construed to imply any other relationship between the modified items or terms. In the case of FIG. 1, the second computing system 102 is in communication with the first computing system 101. As an example, each of the first computing system 101 and the second computing system 102 may be constructed as described below for the computing system 500 of FIG. 5.

[0018] The first computing system 101 controls portions of the second computing system 102 to ensure that the particular entity 103 is present on the second computing system. The physical presence of the particular entity 103 on the second computing system is represented by line 104. The particular entity 103 may be a human user of the second computing system 102. Alternatively, the particular entity 103 may be an executable component running on the second computing system 102. As an example, if the second computing system 102 is configured as described below for computing system 500, the executable component 103 may be configured as described below for executable computing 506 of FIG. 5. In one example, referred to herein as a "hotel check-in kiosk example," the second computing system 102 is a hotel kiosk, the particular entity 103 is a hotel customer checking in, and the first computing system 101 is a hotel computer.

[0019] The second computing system 102 includes a proof capture component 122 configured to automatically generate evidence (hereinafter referred to as "presence evidence") that a particular entity 103 is physically present at the second computing system 102 (as represented by line 104). As merely one example, if the particular entity 103 was a human user, the proof capture component 103 could be configured to capture a biometric of the human user. As an example, the proof capture component could be a camera driver configured to take a picture of the human user. Such a picture taken by the camera would indeed prove that the human user is physically present at the second computing system 103. Of course, such a picture would be taken with appropriate information and prompts to the human user ensuring proper consent, or under circumstances suggesting implicit consent.

[0020] The first computing system 101 controls the proof capture component 122 on the second computing system 101 (as represented by line 105). As an example, this control is possible when the owner of the first computing system 101 and the owner of the second computing system 102 are the same. For example, in a hotel check-in kiosk embodiment, both the kiosk and the hotel computer belong to the hotel. Thus, the hotel computer (which is an example of the first computing system 101) controls the camera (which is an example of the proof capture component 122) on the check-in kiosk (which is an example of the second computing system 102). In another example, the control 105 is enabled even when the first computing system 101 and the second computing system 102 are remote and / or owned by different entities. A particular entity 103 may grant the first computing system 101 control of the proof capture component 122 at the start of a communication session (for example). As an example, this may be done using a verifiable certificate. The first computing system 101 may, for example, visually display an authentication request (e.g., in the form of a QR code) to the second computing system 102, where the authentication request includes a request for permission to use the camera on the user's mobile phone. The user may then provide authentication and permission when the session begins or during registration. The first computing system 101 may then activate the camera on the second computing system 102 by presenting a verifiable certificate that indicates that the first computing system 101 does in fact have that permission.

[0021] Figure 2 illustrates a flowchart of a method 200 for a first computing system to receive a communication from a second computing system, according to principles described herein. The method 200 of Figure 2 may be implemented within the environment 100 of Figure 1, where the method 200 is for the first computing system 101 to receive a communication from the second computing system 102. Accordingly, the method 200 of Figure 2 will now be described with frequent reference to the environment 100 of Figure 1.

[0022] In the context of FIG. 1, the method 200 may be performed by an executable component 111 of a first computing system. The executable component 111 may be constructed as described below for the executable component 506 of FIG. 5. Specifically, the executable component 111 may be instantiated and / or operated in response to one of more processors of the first computing system 101 executing computer-executable instructions that are constructed to instantiate and / or operate the executable component. When the method 200 is performed by the first computing system 101, the first computing system 101 may be constructed to perform the method 200 in response to the first computing system 101 accessing a computer program product having computer-executable instructions thereon that are constructed to cause the first computing system 101 to perform the method 200 when executed by one or more processors of the first computing system 101.

[0023] Method 200 includes an act of controlling a proof capture component of a second computing system to automatically generate existence proof that a particular entity exists at the second computing system (act 211). For example, in FIG. 1, first computing system 101 (or, specifically, executable component 111) causes proof capture component 122 to capture proof that a particular entity 103 exists at second computing system 102.

[0024] Method 200 then includes an act of causing the second computing system to automatically include the generated presence evidence when communicating from the second computing system to the first computing system (act 212). With reference to Figure 1, when the second computing system 102 sends a communication to the first computing system 101, the first computing system 101 (e.g., using executable component 111) causes the second computing system 102 to automatically include the presence evidence. Figure 3 illustrates an example communication 300 that includes presence evidence 310.

[0025] Thereafter, method 200 includes performing certain operations for each of at least one or more (possibly multiple) communications received from the second computing system. These certain operations are shown enclosed within dashed box 213. The certain operations within box 213 may be performed for all communications received from the second computing system, but may also be performed for a single communication received, or only some of the communications received from the second computing system. Additionally, the certain operations may be performed for one, some, or all of the communications received from the second computing system as part of a session between the first and second computing systems.

[0026] 2, for each received communication, the first computing system (e.g., using executable component 111) processes the communication (act 220). This is accomplished by reading presence evidence from the communication (act 221) and then inferring from the presence evidence whether a particular entity exists at the second computing system (decision block 222).

[0027] If the presumption is that the particular entity exists in the second computing system ("yes" at decision block 222), the communication is passed on (operation 223). Passing on the communication means that the process assumes that it is true that the particular entity exists in the second computing system. Referring to the example of FIG. 1, the first computing system 101 processes the communication from the second computing system 102 by treating it as true that the particular entity 103 exists in the second computing system 102. In other words, given that the particular entity 103 is trustworthy for the first computing system 101, the first computing system 101 may conclude that the received communication is not a phishing attack.

[0028] On the other hand, if the presumption is not that the particular entity exists in the second computing system ("no" at decision block 222), the communication is stopped (operation 224). Stopping the communication means that the processing does not treat as true that the particular entity exists in the second computing system. Referring to the example of FIG. 1, the first computing system 111 processes the communication from the second computing system 102 without treating as true that the particular entity 103 exists in the second computing system 102. This stopping may include simply ignoring the communication. After all, the first computing system 101 has not been able to verify that the received communication is not a phishing attack. Thus, when the first computing system 101 establishes a session or other relationship with the second computing system 102, and more specifically with a particular entity that exists in the second computing system 102, the first computing system 101 may establish what constitutes sufficient proof that the particular entity is in the computing system with which the first computing system 101 is communicating. The first computing system 101 may then check that the second computing system 102 can provide evidence that the particular entity 103 exists at the second computing system when future communications are received from a computing system claiming to be the second computing system 102. This provides greater assurance that the first computing system 101 is communicating with the particular entity 103 and not with another entity masquerading as that particular entity 103.

[0029] Similarly, the second computing system 102 may perform the same method when it receives a communication from the first computing system 101. In that case, the second computing system 102 will be in control of the proof capture component of the first computing system and will be able to verify that a particular entity exists on the first computing system. FIG. 4 illustrates an example environment in which the above process may be performed bidirectionally. Here, the first computing system 101 further includes a proof capture component 422 that is controlling (as represented by line 405) an executable component 411 running on the second computing system 102. The executable component 411 may be constructed as described below for the executable component 506 of FIG. 5. In particular, the executable component 411 may be instantiated and / or operated in response to one of more processors of the second computing system 201 executing computer-executable instructions that are constructed to instantiate and / or operate the executable component. When method 200 is performed by a second computing system 102, the second computing system 102 may be configured to perform method 200 in response to accessing a computer program product having computer-executable instructions thereon that, when executed by one or more processors of the second computing system 102, are configured to cause the second computing system 102 to perform method 200. Thus, whenever particular entities 403 and 103 communicate with each other through their respective computing systems 101 and 102, the computing systems may periodically verify that communications received from the other party are truly from the other party and not from some other unexpected or deceptive party. Thus, the principles described herein prevent phishing attacks by an entity convincingly posing as another entity.

[0030] A particular entity 403 may be a human user of the first computing system 101, or perhaps an executable component running on the first computing system 101. Similarly, a particular entity 103 may be a human user of the second computing system 102, or perhaps an executable component running on the second computing system 102.

[0031] In cases where the other entity is a human user, the presence evidence may be a biometric of the human user, in which case inferring whether the presence evidence indicates that the human user is still present at the other computing system (decision block 222) may include comparing the included biometric to recent communications involving the user's previously captured biometric.

[0032] There may be cases where an exact match of biometrics should indicate that the previously captured biometric has been stolen and replayed. This would indicate that somehow the computing system has lost control of the proof capture component of the other computing system. Thus, there may be a certain level of expected difference between the previously captured biometric and the current biometric that is sufficient to allow a conclusion that the biometrics are of the same human user, but different enough to reflect different instances of measurement of the human user's biometric. As an example, a photo taken at the start of a communication may not be exactly the same as a recently taken photo when compared pixel by pixel. Nevertheless, the recognition would still recognize the human user as the same person.

[0033] In the case where the other entity is an executable component, the proof of existence may be a signal that is signed at least in part by information provided by the other party. As an example, assume that the entity 103 is an executable component. The first computing system 101 may provide a key, such as a distributed identifier (e.g., DID) key, to the executable component of the second computing system 102. The second computing system 102 will then capture the proof of the existence of the executable component 103 by signing a communication with that information provided by the executable component 103. Such a signature represents evidence that the executable component 103 exists on the second computing system 102. This executable component may be, for example, a session component that exists during a session between the two computing systems. As an example, assume that the first computing system is a hotel computer and the second computing system is a kiosk owned by the hotel. A particular entity in the presence of the hotel computer may be an auto-check-in component running on the hotel computer. A particular entity in the presence of a kiosk may be a hotel customer who has just approached the kiosk and indicated to the kiosk their intent to check in. A particular user at the kiosk provides a DID key into the kiosk, which is provided to the hotel computer. The hotel computer takes a picture of the hotel customer and provides the picture to the hotel computer as well. For privacy purposes, the user may also provide an ephemeral key that cannot be correlated across applications, instead of using a DID or biometric that is tied to the user.

[0034] Now assume that the hotel computer sends an authentication request to the kiosk asking the user to authenticate themselves. This authentication request is signed using a DID key provided by a particular user, allowing the kiosk to verify that the authentication request really comes from an entity on the hotel computer. Thus, the authentication request is revealed to the hotel customer. The hotel computer prompts the user for authentication information and takes a picture of the hotel customer. The information is then sent to the hotel computer along with the hotel customer's picture. The hotel computer compares the two pictures of the customer (one taken when the session begins and the other when the customer's information is submitted) and determines that the information comes from the customer. This makes it much harder for someone to eavesdrop on the conversation after the session begins and thereby conduct a phishing attack.

[0035] Since the principles described herein are implemented in the context of a computing system, some introductory discussion of a computing system is described in connection with FIG. 5. Computing systems are now taking an increasingly wide variety of forms. A computing system can be, for example, a handheld device, an appliance, a laptop computer, a desktop computer, a mainframe, a distributed computing system, a data center, or even a device not traditionally considered a computing system, such as a wearable (e.g., glasses). In this description and in the claims, the term "computing system" is broadly defined to include any device or system (or combination thereof) that includes at least one physical, tangible processor and a physical, tangible memory thereon that can have computer-executable instructions that can be executed by the processor. The memory can take any form and can depend on the nature and form of the computing system. A computing system can be distributed across a network environment and can include multiple constituent computing systems.

[0036] As shown in FIG. 5, the computing system 500, in its most basic configuration, includes at least one hardware processing unit 502 and memory 504. The processing unit 502 includes a general-purpose processor. Although not required, the processing unit 502 may also include a field programmable gate array (FPGA), an application specific integrated circuit (ASIC), or any other dedicated circuitry. In one embodiment, the memory 504 includes physical system memory. The physical system memory may be volatile, non-volatile, or some combination thereof. In a second embodiment, the memory is non-volatile mass storage, such as a physical storage medium. When the computing system is distributed, the processing, memory, and / or storage functions may also be distributed.

[0037] Computing system 500 also has a number of structures thereon, often referred to as "executable components." For example, memory 504 of computing system 500 is shown to include executable component 506. The term "executable component" refers to a structure that is well understood by those skilled in the art of computing as a structure that may be software, hardware, or a combination thereof. For example, when implemented in software, those skilled in the art will understand that the executable component structure may include software objects, routines, methods (and the like) that may be executed on a computing system. Such executable components may reside in a number of computing systems, computer readable storage media, or combinations.

[0038] Those skilled in the art will appreciate that the structure of an executable component resides on a computer-readable medium such that, when interpreted by one or more processors (e.g., processor threads) of a computing system, it causes the computing system to perform a function. Such a structure may be directly computer readable by the processor (as in the case where the executable component is binary). Alternatively, the structure may be constructed to be interpretable and / or compiled (in a single stage or multiple stages) to generate a binary that is directly interpretable by the processor. Such an understanding of an exemplary structure of an executable component is well within the understanding of those skilled in the art of computing when using the term "executable component."

[0039] The term "executable component" will also be understood by those skilled in the art to include structures such as hard-coded or hard-wired logic gates that are implemented exclusively or nearly exclusively in hardware, such as in a field programmable gate array (FPGA), application specific integrated circuit (ASIC), or any other dedicated circuit. Thus, the term "executable component" is a term for structures implemented in software, hardware, or a combination that are well understood by those skilled in the art of computing. In this description, terms such as "component," "agent," "manager," "service," "engine," "module," "virtual machine," and the like may also be used. In this description, and in this case, these terms (with or without modifiers) are also intended to be synonymous with the term "executable component," and also have structures that are well understood by those skilled in the art of computing.

[0040] In the following description, embodiments are described with reference to operations performed by one or more computing systems. When such operations are implemented in software, one or more processors (of the associated computing system performing the operations) direct the operation of the computing system in response to executing computer-executable instructions that constitute the executable components. For example, such computer-executable instructions may be embodied on one or more computer-readable media that form a computer program product. One example of such operations includes the manipulation of data. When such operations are implemented exclusively or nearly exclusively in hardware, such as in an FPGA or ASIC, the computer-executable instructions may be hard-coded or hard-wired logic gates. The computer-executable instructions (and the data to be manipulated) may be stored in memory 504 of the computing system 500. The computing system 500 may also include a communication channel 508 that allows the computing system 500 to communicate with other computing systems, for example, via a network 510.

[0041] Although not all computing systems require a user interface, in some embodiments, the computing system 500 includes a user interface system 512 for use in interfacing with a user. The user interface system 512 may include an output mechanism 512A as well as an input mechanism 512B. The principles described herein are not limited to the exact output mechanism 512A or input mechanism 512B, as such will depend on the nature of the device. However, the output mechanism 512A may include, for example, a speaker, a display, a haptic output, virtual or augmented reality, a hologram, etc. Examples of the input mechanism 512B may include, for example, a microphone, a touch screen, virtual or augmented reality, a hologram, a camera, a keyboard, a mouse or other pointer input, any type of sensor, etc.

[0042] The embodiments described herein may comprise or utilize a special-purpose or general-purpose computing system including computer hardware, such as one or more processors and system memory, as discussed in more detail below. The embodiments described herein also include physical and other computer-readable media for carrying or storing computer-executable instructions and / or data structures. Such computer-readable media may be any available media that can be accessed by a general-purpose or special-purpose computing system. Computer-readable media that store computer-executable instructions are physical storage media. Computer-readable media that carry computer-executable instructions are transmission media. Thus, by way of example and not limitation, embodiments of the present invention may include at least two distinctly different kinds of computer-readable media: storage media and transmission media.

[0043] Computer readable storage media include RAM, ROM, EEPROM, CD-ROM, or other optical disk storage, magnetic disk storage, or other magnetic storage devices, or any other physically tangible storage medium that can be used to store desired program code means in the form of computer-executable instructions or data structures and that can be accessed by a general-purpose or special-purpose computing system.

[0044] A "network" is defined as one or more data links that enable the transport of electronic data between computing systems and / or modules and / or other electronic devices. When information is transferred or provided over a network or another communications connection (hardwired, wireless, or a combination of hardwired or wireless) to a computing system, the computing system properly considers the connection to be a transmission medium. A transmission medium may be used to carry desired program code means in the form of computer-executable instructions or data structures and may include a network and / or data links that may be accessed by a general-purpose or special-purpose computing system. Combinations of the above should also be included within the scope of computer-readable media.

[0045] Furthermore, when reaching various computing system components, program code means in the form of computer-executable instructions or data structures may be automatically transferred from a transmission medium to a storage medium (or vice versa). For example, computer-executable instructions or data structures received over a network or data link may be buffered in a RAM in a network interface module (e.g., a "NIC") and then ultimately transferred to the computing system's RAM and / or a less volatile storage medium of the computing system. Thus, it should be understood that storage media may be included within computing system components that also (or even primarily) utilize transmission media.

[0046] Computer-executable instructions include, for example, instructions and data that, when executed by a processor, cause a general-purpose computing system, a special-purpose computing system, or a special-purpose processing device to perform a certain function or group of functions. Alternatively or additionally, computer-executable instructions may configure a computing system to perform a certain function or group of functions. Computer-executable instructions may be, for example, binaries, or even intermediate format instructions such as assembly language, or even source code, instructions that have undergone some translation (such as compilation) before direct execution by a processor.

[0047] Although the subject matter has been described in language specific to structural features and / or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the described features and acts are disclosed as example forms of implementing the claims.

[0048] Those skilled in the art will appreciate that the present invention may be practiced in a networked computing environment involving many types of computing system configurations including personal computers, desktop computers, laptop computers, message processors, handheld devices, multiprocessor systems, microprocessor-based or programmable consumer electronics, network PCs, minicomputers, mainframe computers, cell phones, PDAs, pagers, routers, switches, data centers, wearables (such as glasses), and the like. The present invention may also be practiced in a distributed system environment where tasks are performed together by local and remote computing systems that are linked through a network (by hardwired data links, wireless data links, or a combination of hardwired and wireless data links). In a distributed system environment, program modules may be located in both local and remote memory storage devices.

[0049] Those skilled in the art will also appreciate that the present invention may be implemented in a cloud computing environment. A cloud computing environment may, but need not, be distributed. When distributed, a cloud computing environment may have components that are distributed internationally within an organization and / or owned across multiple organizations. In this description and in the claims that follow, "cloud computing" is defined as a model for enabling on-demand network access to a shared pool of configurable computing resources (e.g., networks, servers, storage, applications, and services). The definition of "cloud computing" is not limited to any of the many other benefits that may be obtained from such a model when properly deployed.

[0050] In the processes and methods disclosed herein, the operations performed in the processes and methods may be implemented in various orders. Moreover, the outlined operations are provided only as examples, and some of the operations are optional, may be combined into fewer steps and operations, supplemented with other operations, or expanded into additional operations without detracting from the essence of the disclosed embodiments.

[0051] The present invention may be embodied in other specific forms without departing from its spirit or characteristics. The described embodiments should be considered in all respects as merely illustrative and not restrictive. The scope of the present invention is therefore indicated by the appended claims, rather than by the above description. All changes that come within the meaning and range of equivalency of the claims are to be embraced within their scope.

Claims

1. 1. A first computing system, comprising: one or more processors; One or more computer-readable media having computer-executable instructions; Equipped with The computer-executable instructions, when executed by the one or more processors, controlling a proof capture component of the second computing system to automatically generate evidence of presence that a particular entity exists at the second computing system; causing the second computing system to include the generated presence evidence when communicating from the second computing system to the first computing system; for each of at least one of the one or more communications received from the second computing system, reading the evidence of presence from the communication; and inferring from the presence evidence whether the particular entity is present at the second computing system; and if the presumption is that the particular entity resides on the second computing system, passing on the communication, thereby treating the particular entity as resided on the second computing system; if the presumption is not that the particular entity is present at the second computing system, stopping the communication, thereby not treating the communication as if the particular entity were present at the second computing system. and processing said communication by performing configured to cause the first computing system to communicate with the second computing system by A first computing system.

2. 1. A method for a first computing system to communicate with a second computing system, comprising: controlling a proof capture component of the second computing system to automatically generate evidence of presence that a particular entity exists on the second computing system; causing the second computing system to include the generated presence evidence when communicating from the second computing system to the first computing system; for each of at least one of the one or more communications received from the second computing system, reading said evidence of presence from said communication; inferring from the presence evidence whether the particular entity is present at the second computing system; if the presumption is that the particular entity resides on the second computing system, passing the communication, thereby treating the particular entity as residing on the second computing system; if the inference is not that the particular entity is present at the second computing system, stopping the communication, thereby treating the communication as not being from the particular entity; and The method includes:

3. The method of claim 2 , wherein the particular entity is a human user of the second computing system.

4. The method of claim 3 , wherein the presence evidence is a biometric of the human user.

5. 5. The method of claim 4, wherein the biometric of the human user is a picture of the human user and the proof capture component is a camera of the second computing system.

6. 5. The method of claim 4, wherein the inference of whether the particular entity is present at the second computing system from the presence evidence includes comparing the biometric of the human user to a previously captured biometric of the human user.

7. The method of claim 2 , wherein the particular entity is an executable component running on the second computing system.

8. The method of claim 7 , wherein the evidence of existence is a verifiable certificate of the executable component.

9. 8. The method of claim 7, wherein the proof of existence is a signature signed at least in part by information provided by the first computing system.

10. 8. The method of claim 7, wherein the executable component is a session component such that the first computing system communicates with a second computing system in a session associated with the session component.

Images