|Número de publicación||US7406542 B2|
|Tipo de publicación||Concesión|
|Número de solicitud||US 10/379,340|
|Fecha de publicación||29 Jul 2008|
|Fecha de presentación||3 Mar 2003|
|Fecha de prioridad||1 Mar 2002|
|También publicado como||EP1488313A2, US20030179244, WO2003075158A2, WO2003075158A3|
|Número de publicación||10379340, 379340, US 7406542 B2, US 7406542B2, US-B2-7406542, US7406542 B2, US7406542B2|
|Cesionario original||Google Inc.|
|Exportar cita||BiBTeX, EndNote, RefMan|
|Citas de patentes (52), Otras citas (16), Citada por (14), Clasificaciones (7), Eventos legales (4)|
|Enlaces externos: USPTO, Cesión de USPTO, Espacenet|
This application claims priority to U.S. Provisional Application No. 60/361,180, entitled “ASSURED DENOTATION OF APPLICATION SEMANTICS,” filed Mar. 1, 2002, which is expressly incorporated herein by reference.
This invention relates generally to computer systems and user applications and, more particularly, to a method and system for assured denotation of application semantics (“ADAS”).
The advent of time-shared, multi-user graphical systems gave individual users the ability to interact simultaneously with a single computer system or workstation. For example, in the 1970s, Unix® with X Windows allowed users, e.g., system administrators, to interact simultaneously with the computer system as a “normal user” or a “super user” using any number of windows on a single desktop (“desktop sharing”) of the computer system. Typically, minimal privileges were given to a normal user interacting with the computer system, whereas a full set of privileges were given to a super user to maintain and configure the computer system. Separate windows could be used for operating as a normal user and a super user. Generally, to determine if a particular window or interaction area was designated for a normal user or a super user, the user had to make explicit queries, such as “whoami” queries. A disadvantage of these types of systems is that they lack a clear indication of the context regarding the operation of the user. Furthermore, making explicit queries to determine the context of a user's activity hampers work productivity and does not assure the return of correct information.
Thus, operating as multiple users on prior desktop sharing systems can be problematic due to the lack of a clear denotation for each window or user interaction area. For instance, these systems did not discriminate whether a window was supporting a normal user with minimal privileges or a super user with a full set of privileges. Nevertheless, despite the lack of a clear denotation for each window, advanced users could perform multiple tasks as multiple users in multiple windows without error, but this required careful operation and knowledge of the context for each window to perform the desired task. Otherwise, an inadvertent error could result such as deletion of files due to a command executed in a window with a full set of privileges.
Modern operating systems, such as the Microsoft Windows® family of operating systems, also provide desktop sharing. In particular, Microsoft Windows XP® allows a display to support simultaneously multiple desktops, with only one being displayed at time. A user can switch between the desktops with any combination of keyboard sequences. A number of disadvantages exist for these types of systems that provide separate desktops for different user contexts. For instance, switching between different desktops or having a desktop in a window is not very clear, nor scalable, as each desktop is similar to each other, which can also be similar to the user's original desktop. Moreover, each desktop is disjointed and not integrated into the user's original desktop. This is cumbersome and awkward to the user, eliminating otherwise available functionality that hinders the user's ability to perform operations.
Other graphical operating systems and platforms have also used portions of the desktop for activity separate and distinct from the regular environment of a user. For example, remote-access software such as PCAnywhere emulates an entire desktop within a single window on a display of a remote computer system. Likewise, virtual machine software such as Vmware emulates a desktop similar to PCAnywhere. However, these modern operating systems discourage users from operating as multiple users to avoid user confusion. That is, users are encouraged to work exclusively as one user on the computer system.
One technology that also provides for desktop sharing is Java applets. Java applets are programs that can be sent along with a Web page to a user. These programs can perform, e.g., interactive animations, immediate calculations, or other simple tasks without having a user send a request back to a server. Unfortunately, Java applets may originate from untrusted, or even hostile, Web pages. Therefore, their use should be suspect and restricted for purposes of security. In particular, Java applets should be restricted from persistently affecting a user's sensitive data. Sensitive data such as passwords should not be entered within a Java applet window.
A Java applet window can be marked as an “Untrusted Applet Window,” which is to remind users not to enter sensitive data. However, using markings provided by Java's “Untrusted Applet Window” fails to be universal or scalable. That is, it functions only for the limited set of applications designed and implemented as Java applets, and, for each of those, shows the same type of alert message, regardless of the applet's context. In addition, the type of marking provided by Java can be tampered with, either inadvertently or maliciously, by non-Java-applet activity on a computer system, e.g., through user actions.
Today, with the availability of desktop sharing systems, a user can perform a variety of different types of activities that have distinctly different relationships with the user's environment. For example, the user can perform activities intended for a corporate or home environment, which produce different types of user interactions and activities. For instance, in a home environment, the user may wish to view Web pages or emails without affecting their environment. In a corporate environment, the user may desire to try new software, installing it on a trial basis, with the intent to revert all of its effects. Furthermore, in a corporate environment, the user may wish to share or link information with other users through “extranets” or “peer-to-peer services.” Thus, segregating, limiting, and modifying the potential effects of such activities are desired on desktop sharing systems.
User accounts can limit the effects of activities by different users to that intended and expected by the users on desktop sharing systems. In particular, user accounts encapsulate the information particular to each individual user, such as the user's name, password, area of transient and persistent storage, configuration information, resource-usage quotas and other properties to be enforced on the user's behavior. By using user accounts, time sharing could be implemented without compromising the systems usability. Whereas previous computer system operations always directly affected the global state of the machine, operations on a user's behalf in systems implementing user accounts typically affect only the information in the user's account. In this manner, each user's actions became isolated from other users since, for the most part, they only affected the individual user's account information.
Thus, user accounts can be very useful. They enhance usability when multiple individuals simultaneously use a computing system and allow for segregation of system activity based on intent. For example, conventional systems may use a supervisor user account, called “root,” to run background services. Also, web-server activities may operate as “nobody,” that is, a user account with very limited privileges. Additionally, user accounts are integral to maintaining the security of a multiple user computer system since they may be used to control which data a user may access or actions a user may perform.
Furthermore, as disclosed in co-pending and commonly owned U.S. patent application Ser. No. 10/144,048, entitled “METHODS AND SYSTEMS FOR USING DERIVED USER ACCOUNTS,” filed May 10, 2002, which is incorporated herein by reference, derived user accounts (“DUAs”) can also limit the effects of activities by different users to that intended and expected by the users. DUAs are essentially identical to a user's normal working environment, and are designed to enable non-expert users to align their actions with desired intent and potential effects. In particular, DUAs are generated from user accounts in which a DUA is linked to an existing original user account (“OUA”). By using a DUA, its linked OUA may be selectively isolated from system operations. Thus, an advantage of using DUAs is that they are derived from the user's actual environment, and can be arbitrarily integrated with that environment. This enhances the user's ability to work more productively and instinctively with the workstation or desktop. Yet, even using DUA's, there is still no clear denotation or indication that a user is operating within a particular DUA.
Various graphical systems have been proposed, as described in U.S. Pat. No. 6,323,884 and U.S. Pat. No. 5,377,317, to address limited aspects of helping users coordinate their actions in graphical interaction systems. More particularly, graphical systems have been designed, as described in U.S. Pat. No. 5,760,769 and U.S. Pat. No. 5,790,127, that focus on helping users avoid confusion when performing “application sharing” such as when users interact with windows representing activity on remote computers connected, e.g., via teleconferencing with the user's desktop graphical interaction area or in a window. Although teleconferencing application sharing mechanisms can mark the teleconferencing application, these systems do not mark the user's other applications, only those connected via teleconferencing, and do not provide scalability for other types of contexts. In addition, these mechanisms suffer from the same lack of assurance as Java's applet mechanisms. Furthermore, such systems do not clearly or consistently denote and circumscribe different types of activity, nor do they implement mechanisms to limit the effects of the different types of activity without specific tailoring of the applications.
Therefore, as users operate in different environments, it is important that the context of a user's activity be clearly and unambiguously marked in order to provide the users with an indication on how to interact within a particular activity. Thus, there is a need for clear denotation of application semantics, as a user bases interactions with a desktop application based on the context of those applications, i.e., their semantics.
According to one aspect of the invention, in a computer system operating at least one application, a method is disclosed for providing assured denotation of application semantics associated with the application. A graphical operation is received for the application. The graphical operation includes at least one argument. The argument is intercepted for the graphical operation, and modified for the graphical operation to provide an indication of at least one application semantic associated with the application.
According to another aspect of the invention, a computing system is disclosed that comprises at least one memory having program instructions to execute at least one program component, and at least one processor to execute the program instructions to receive a graphical operation for the application. The graphical operation includes at least one argument. The at least one processor also executes the program instructions to intercept the argument for the graphical operation and to modify the argument for the graphical operation to provide an indication of at least one application semantic associated with the application.
The accompanying drawings, which are incorporated in, and constitute a part of the specification, illustrate exemplary implementations and embodiments of the invention and, together with the detailed description, serve to explain the principles of the invention. In the drawings,
Reference will now be made in detail to exemplary implementations and embodiments of the invention, examples of which are illustrated in the accompanying drawings. Wherever possible, the same reference numbers will be used throughout the drawings to refer to the same or like parts.
Processing techniques are disclosed for desktop applications that overcome the disadvantages of prior desktop systems and provide a clear and noticeable denotation of application semantics (ADAS). The application semantics, i.e., a type of activity regarding an application, can be clearly marked with a distinct and noticeable indication delineating a particular activity for the application.
In some embodiments, a system can provide a desktop with a graphical denotation that outlines a portion of a window or graphical user interaction area. The graphical denotation represents a particular type of activity or application semantics that provides an indication of the context being implemented or performed for the application. The graphical denotation can also be used within a particular DUA, as described below, to indicate a particular activity within the DUA.
Thus, the following techniques enable users to have a clear and consistent indication of the semantics of application execution in order to differentiate between various types of activities, which may have different possible effects. This allows user to interact with the desktop in a manner appropriate for a particular activity by knowing the context of each activity being performed.
B. Derived User Accounts
Derived user accounts (DUAs) will now be described for certain system operations. DUAs may have all of the properties of traditional user accounts including, but not limited to, its own state, distinct privilege and access control rules, its own unique identifier (such as a security token), and ownership of any system resources. In addition, DUAs are linked to at least one particular existing user account (the Original User Account, or OUA). Through use of a DUA, its OUA may be selectively isolated from system operations taking place in the DUA's context. Since the DUA is a legitimate user account, legacy processes will function correctly in a DUA context while modifications to the OUA can be limited through choice of derivation transformations (“DTs”) specified by a set of derivation rules (“DRs”).
If the software application is not running in the context of the DUA, the application determines if a DUA should be “created” (step 222). If the application determines that a DUA should not be created, the application continues normally as in step
If it is determined that a DUA should be created (step 224), a DUA may be created according to any of the following exemplary embodiments. In some embodiments consistent with the present invention, a DUA shell may be created by, for example, creating a new user account, “user 2,” that may comprise a set different than, or a subset of, the rights and permissions afforded the original user. A DUA shell is the context and the mechanism for propagating the context. The context includes, for example, all information that would normally be associated with an operation in the OUA, such as user credentials, process id, and other information. DUA shells allow for the automatic propagation of DUA context to all DUA activity, for example, processes or threads, whether they be created directly or indirectly as a result of DUA activity. The initial DUA shell may have been established before run-time or established dynamically during operation of the operating system. The creation of the DUA shell may have been invoked randomly or triggered by some event, such as a write access operation.
In this exemplary embodiment, the new user account may comprise rights and permissions that the original user does not have. The new user account, or DUA shell, may be created, for example, by using the existing user account mechanisms in the operating system. Additionally, the ownership of files or objects created or owned by user 2 may need to be modified post-creation to allow the corresponding OUA to have access, if access by OUA is desired. Similarly, user 2 may, by default, access to none or all of the files or objects created or owned by the OUA.
In another exemplary embodiment, a DUA shell may be created by creating a new, possibly restricted, login session or token for the OUA (called OUA′, or “OUA prime”). OUA′ is distinct and separate from the original OUA session or token, but may have all the same privileges for resources as the OUA, such as, for example, ability to use the same display. In some exemplary embodiments, OUA′ may have fewer capabilities than OUA (for example, may not be able to shut down the machine or modify the screen resolution). However, by creating a DUA shell in this fashion in, for example, the Microsoft Windows operating system, the activity of OUA′ may be discriminated as the associated token that is automatically propagated to any processes, thread, or other activity created directly or indirectly by OUA.
In yet another embodiment, a process group (in Windows 2000, a “job”) may implement the DUA shell. As well as being able to implement a DUA shell, a process group or job may also enforce quotas on resource consumption and, in other ways, control access to resources. For example, a process group or job may perform the automatic context propagation needed for discrimination of the DUA activity.
In still another embodiment, a DUA shell may be created by annotating certain OUA activity as actually belonging to the DUA. Annotation occurs when new OUA activity (that actually belongs to the DUA) is initiated such as, for example, on the creation of a thread, process, or other activity, or the impersonation of the OUA. Annotation may take the form of unique bits or an arbitrary sequence of bits associated with the OUA activity. One example is the use of a distinguished entry in handle tables or file descriptor tables. The annotation may be placed on any one or more components of the OUA activity. In addition, the annotation may be placed on any information in the kernel thread control block (“TCB”) or kernel process control block (“PCB”), assuming execution in an operating system with a protected mode kernel. One benefit of annotating information in the kernel TCB or PCB is that the annotation can not be compromised by DUA application activity. In certain embodiments, it is preferred that the annotations are not modified in the ordinary course of events.
In some embodiments where DUA shell implementations automatically propagate the context, the annotation may be done automatically. In other embodiments, such as the embodiment immediately above, new threads, processes, or other activity of the DUA, and those impersonating the DUA, may need to be intercepted and annotated as being in DUA, not OUA, context. In still further embodiments, annotation may involve a combination of automatic annotation and non-automatic annotation.
The DUA may be initialized and maintained based on derivation transformations (“DTs”) and derivation rules (“DRs”). Derivation rules are a set of rules that link any aspect of a DUA with the corresponding aspect of its OUA. The derivation rules for a resource, X, include derivation transformations, which are computable functions that take an input, modify the input, and return an output. An argument derivation transformation (“ADT”) generally receives an argument as input, modifies the input, and returns a second argument as output, although in some embodiments, the ADT does not modify anything. A result derivation transformation (“RDT”) takes as input certain values, modifies the values, and returns modified values. An “update DT” or “UDT” may update the state of a DUA based on its corresponding OUA whereas a “feedback DT” of “FDT” may give feedback from the state of a DUA to the state of its corresponding OUA.
The derivation rules and transformations may be authored by a developer or system administrator. In some embodiments, the derivation rules and transformations may be initially authored by a developer or system administrator but are later modified dynamically. Dynamic rules may be modified during run time according run time dependent conditions or other conditions.
In one embodiment, the derivation rules may take the form of script-like directives. For example, an author of rules may use a text editor or similar device to create a human-readable text file containing the rules. In other embodiments, the rules may be authored in semantic formats such as or similar to known scripting languages or high-level computer languages, or in other formats well know to those skilled in the computer software arts. In still other embodiments, the rules are compiled or otherwise processed by a rule generator into a machine-readable form, which is in turn used by the computer system at run time.
The following is one example of derivation rules consistent with the present invention. The first table comprises an exemplary set of rules for DUA events; the second table comprises an exemplary set of rules for OUA events. Each line in the tables represents a derivation rule which describes the actions that will take place for a particular resource access.
As shown in the first line of the DUA table above, if an application operating in DUA context refers to /A/B (“orgname”), and the operation is “read”, an update derivation transformation, Z, will be performed using /OUA/A/B as the source (“name1”) and /DUA/A/B as the destination (“name2”), after which the actual read operation will be performed on the destination. This in one example of an ADT.
In the example above, the update transformation, Z, may also be followed or preceded by a feedback transformation, T, using /DUA/A/B as the source (“name2”) and /OUA/A/B as the destination (“name1”).
If an application refers to /R/S/ and the operation is “open”, the UDT, V, will be performed taking /MASQ/R/S as the input and /DUA/R/S as the output, after which the open operation will actually be performed on /DUA/R/S. /MASQ/R/S is data introduced by the DUA mechanism or the rules and, as described below, may be unrelated to the OUA.
In some embodiments, whether or not a DT is specified, the operation is performed on an actual named resource or object, with the rules having as a default one of the names specified in the DUA table above. In this particular example, name2 represents the actual named resource accessed by all operations by default as specified by design. As shown in the third line of the DUA table, in some embodiments, the operation may be performed on name1, as specified, overriding the default case. This last example may be considered one example of an ADT, as the orgname is modified to name2.
Referring now to the OUA table above, if OUA activity refers to /A/B, and the operation is “read,” the system will perform a feedback transformation, Y, using /DUA/A/B as input and /OUA/A/B as output before actually performing the read operation on /OUA/A/B.
There are many possible types of derivation transformations, some examples of which are as follows. “Equivalence DTs” may be used to ensure certain parts of the DUA state and the OUA state remain identical. In this case, for example, the state of the DUA may be copied back to the OUA in an feedback DT or the state of the DUA may be refreshed, for example, by an update DT that copies over one or more aspects of the DUA with information from the OUA. Equivalence DTs may be useful in cases where it is desired to have changes in either the DUA or OUA automatically reflected in the other. For example, the system volume control state may need an equivalence DT if volume changes in a DUA are to have the expected effect.
A “copying DT” can ensure that parts of DUA state are copies of the corresponding OUA state, and that any modifications are performed only on the DUA copy. Copying DTs may be used to limit the effects of operations in DUA context upon the information of its OUA. Copying DTs may be useful in situations where a user may wish to evaluate effects of operations on the system without applying them to the OUA. One example of this would be during installation of new software or during debugging of software. If errors occur while operating with a modified DUA, the original OUA is never actually modified. Thus, operations may revert to the original OUA, and the system may be very quickly and easily returned to the old state. In some embodiments, a user may wish to use a copy DT in non-experimental situations where the system is deliberately operated in the DUA context with no intentions of ever modifying the OUA. This may be useful, for example, for security or integrity reasons. In these embodiments, the DUA may be deliberately discarded after the requested action is performed without update to the OUA.
Yet another example of a derivation transformation is a “masquerading DT.” Masquerading DTs can specify properties for certain parts of a DUA state, irrespective of the corresponding state of its OUA. Masquerading DTs can be used to perform operations in a DUA where certain states have values unrelated and (perhaps radically) different from that state's values in the OUA. In fact, a masquerading DT may specify that the data for the DUA may be taken from a source other than the OUA. This type of derivation transformation allows operations to be performed in a modified version of the OUA context. Masquerading DTs may be useful in cases of experimentation because the performance of the system using modified state information may be evaluated without modifying the OUA.
A “partitioning DT” ensures that there is no overlap between certain aspects of the DUA and the OUA state, that is, partitioning their namespace or other sets of values. For example, a partitioning DT may assign a new name, Z, to the DUA and rename the resource, X, to be Y, defined as the concatenation of X with Z. Then, the application is allowed to access the resource Y without accessing the original resource X. Partitioning DTs may be necessary when multiple entities, such as the OUA and DUA, or even multiple DUAs, are concurrently sharing resources and each action must have access to, what appears to be, the full capabilities of that resource. One exemplary operation is the simultaneous access of transient or persistent storage by more than one application. Multiple DUAs can concurrently share state—each believing it has full and exclusive access to that state—as long as a partitioning DT creates a new partition of that namespace for each DUA.
A “liveness DT” changes lifetime properties of certain parts of DUA state from those of its OUA, that is, it may make state that is persistent in the OUA transient in the DUA. The OUA may even be purged at regularly timed intervals. Conversely, any other such state meta-information including, for example, access control attributes, may be set to differ using a liveness DT between the DUA and its OUA.
“Dynamic DTs” may be used to specify an arbitrary relationship between a certain state value found in both the DUA and the OUA. For example, in one embodiment consistent with the present invention, a dynamic DT may remove the ability of a DUA to set volume to its maximum value, while still retaining the DUA's ability to perform operations affecting volume—simply, the dynamic DT can set OUA volume value to 90%, if the DUA volume value is set to 90% or higher, otherwise effecting an equivalence DT. Similarly, a dynamic DT can effect the introduction of a named state to the DUA when that state is not found in the OUA, or the removal of a named state from the DUA when that state is found in the OUA. A dynamic DT may implement this, for example, by modifying the behavior of all state namespace enumeration operations—and with the assistance of a partitioning DT, either account can create or remove such (introduced or removed) state independently.
Derivation transformations may also specify that if an original state value is within a range [A,B] specified by the derivation rule, than the corresponding state value in the DUA is the original state value of the OUA. If not, the state value of the DUA becomes either A or B, whichever is closer to the original state value. This update derivation transformation may be referred to as a “Bounded value” DT. Feedback may also be bounded in a similar manner. In a feedback bounded value DT, for example, if a state value of the DUA is within a range [A,B] specified by the derivation rule, the OUA will get the state value of the DUA. Otherwise, the OUA will receive whichever of A or B is closer to the state value of the DUA.
Still other examples of derivation transformations consistent with the present invention operate on metadata. For example, it may be desired to initially provide access to all information in a data or file, but when copying is performed, it is desired to limit copying to the contents and not copy the metadata, such as access control permissions, time stamps, and name of the file. The derivation rule may block the copying of the metadata but may provide different information in its place, that is, some or all of the metadata may be masked.
An “enumeration” transformation excludes or adds information to a list. An “enumeration” transformation is a variety of a masquerading transformation in the sense that it masks the real information by adding members to the real list or deleting actual members from the real list before allowing access to the list.
One skilled in the art will recognize that there exist many possible derivation transformations and derivation rules. The list above is only exemplary and not meant to comprise the universe of allowable derivation transformations and rules.
Referring back to
If the application is already operating in DUA context (step 220), the application is executed using the DUA (step 230). The system determines whether the resource sought by the application relates only to a specific user account (that is, a “local” resource) or is information that is shared between multiple user accounts (step 235). If the resource is shared, or “global,” the DUA contains derived global system state (“DGSS”) information and derivation transformation rules that update or feedback to more than one user account.
In either case, the system determines the type of access requested (steps 240 and 260). Additionally, the DUA or DGSS may optionally be updated by information from the OUA based on the applicable derivation nile before the requested activity is performed (steps 242 and 262). These actions help ensure that the system will have access to the most current information in the OUA. After the DUA or DGSS are updated (steps 242 and 262), the requested activity is performed by reading the DUA or DGSS (steps 244 and 264). Depending on the type of access requested and the derivation transformation rules, the system may optionally communicate changes to the DUA or DGSS back to the OUA in a feedback transformation, if such feedback is indicated (steps 244 and 264).
In each case, after the application performs the requested activity, the system is returned to normal operations (step 280).
The above represents one exemplary embodiment of the present invention. In some embodiments, DUA events can also occur even though no access is being made to the DUA or OUA resources. In particular, DUA events may occur on a resource X at a specific time, or at specific timed intervals, or given the satisfaction of an arbitrary predicate on the system state or the system environment.
C. Exemplary System Architecture
In some embodiments, a software application operating on client 404 may place a request that involves data stored on or instructions that are executed on Server A 440. Since client 404 is directly connected to Server A 440 for example, through a local area network, this request would not normally result in a transfer of data or instructions over what is shown as “network” of
Server system 522 also includes conventional components such as a processor 534, memory 535 (e.g. RAM), a bus 536 which couples processor 534 and memory 535, a mass storage device 537 (e.g. a magnetic or optical disk) coupled to processor 534 and memory 535 through an I/O controller 538 and a network interface 539, such as a conventional modem. It will be appreciated from the description below that the present invention may be implemented in software which is stored as executable instructions on a computer readable medium on the client and server systems, such as mass storage devices 527 and 537 respectively, or in memories 525 and 535 respectively. Rules or derivation transformations may be stored in, for example, memory 525 or mass storage 527 on client system 520 or memory 535 or mass storage 537 on server system 522.
Processors 524 and 534 may be microprocessors such as the Pentium® family microprocessors manufactured by Intel Corporation. However, any other suitable microprocessor, micro-, mini-, or mainframe computer, may be used. Memories 525 and 535 may include a random access memory (RAM), a read-only memory (ROM), a video memory, or mass storage. Mass storage 527 and 537 may include both fixed and removable media (e.g., magnetic, optical, or magnetic optical storage systems or other available mass storage technology). Memories 525 and 535 may contain a program, such as an operating system, an application programming interface (API), and other instructions for performing the methods consistent with the invention.
Derived user accounts also may be generated and used in a system, such as that described in co-pending and commonly assigned U.S. patent application Ser. No. 10/082,591 (“the '591 application”), entitled “ALTERED STATES OF SOFTWARE COMPONENT BEHAVIOUR,” filed Feb. 22, 2002, which is expressly incorporated herein by reference in its entirety.
Techniques for intercepting the request are well known to those of ordinary skill in the software arts. For example, interception of a hardware or software supported system call may comprise redirection of an interrupt service vector to alternative code. For library-based services, interception can take the form of the modification of dynamically-linked libraries (prior to loading or at link time, as desired). For any subroutine or function-based service, redirection of the subroutine call instruction, or machine-code patching of subroutine entry code can be employed. Any service dispatch mechanism based on dynamic name-resolution can be intercepted by a change in the service-lookup namespace.
In other embodiments consistent with the present invention, derivation engine 601 receives a request directly from software component 603. For example, software component 603 may call the derivation engine 601 or derivation engine 601 itself captures software component 603.
Once the request is received by derivation engine 601, either directly or indirectly, derivation engine 601 may consult derivation rules 609, which may be dynamic or static, for assistance in processing the request in accordance with the present invention. Derivation rules 609 comprise derivation transformations, as described above. Based on the derivation rules 609, derivation engine 601 determines how to direct access to a derived user account. For example, if the request specifies to write data to a location A specified by the request, in the DUA context, the arguments 607 of the request may be modified by derivation engine 601 in accordance with derivation rules 609. In one exemplary embodiment, as described with reference to the DUA table shown above, if a request (which in this example is an application) requests that a read operation be performed on original name “/A/B,” and the appropriate derivation rule comprises the derivation transformation, Z, which specifies that read operations on /OUA/A/B should instead be performed on /DUA/A/B, the arguments of the request may be modified so that /DUA/A/B is the source of the data for the read operation.
Once derivation engine 601 modifies arguments 607 in accordance with the derivation rules, derivation engine 601 may pass arguments 607 to predefined code 605 or alternative code 615. In addition, alternative code 615 may invoke predefined code 605 at some point during its execution. In some embodiments, alternative code 615 may modify data 617 or dynamic derivation rules 609. A result 619 may be returned from execution of predefined code 605 or alternative code 615 to derivation engine 601. Derivation engine 601, in turn, returns result 619 to software component 603.
D. Assured Denotation of Application Semantics
The following description regarding
The exemplary embodiment of
The AGD program component 714 can maintain the states of all ADAS indications, including the contexts of the application semantics related to the application process 704 or other application processes. The code for redefined graphical operations 716 can include a library of code or instructions to provide result″ that can provide varying types of ADAS indications, as described below in
The AGD program component 714 can thus interact with code 716 directly, likewise altered states engine 712 can also interact with code 716 directly. The above program components within computer memory 702 can be integrated with an operating system kernel, or any other subsystem that is both protected from subversion by other applications, and can mediate on all graphical operations for application process 704 or other applications.
In some embodiments, using AGD program component 714 and code 716, altered states engine 712 can modify or alter the graphical operation for the application by, e.g., providing a marker or indication circumscribing a target application window, as described in
The arguments for the graphical operation received by the GUI request dispatch 708 are intercepted by interception module 710 (step 804). Interception module 710 can intercept the arguments using techniques as disclosed in the co-pending and commonly assigned '591 application noted above. In this process, interception module 710 forwards the arguments from the received graphical operation to altered states engine 712.
Altered states engine 712 modifies the intercepted arguments for the graphical operation (step 804). For example, referring to
In this process, altered states engine 712 extracts information from the intercepted arguments regarding the position and size of the application's user-interaction area, e.g., the position and size of target application window 902 of
This process of using the program components 714 and 716 can be implemented in a separate and protected process to effect a clear denotation to the user that circumscribes the application's user-interaction area, e.g., ADAS indication 904 for target application window 902 of
The ADAS indications should be clearly and noticeably marked. In particular, the following are exemplary characteristics that ADAS indications should have in order to be noticeable and recognized by a user:
ADAS indications should support multiple, simultaneous DUA's executing applications.
It should be noted that ADAS indication 904 is not obtrusive to the user and does not modify the graphical behavior of target application. In other words, as shown in
Alternatively, regardless of the color schemes used, ADAS indication 904 could be a blinking or animated outline tightly drawn around target application window 902, or irregular in shape for an irregular target application window. For example, ADAS indication 904 can be easily derived from an application window extents and the outlines of shapes from irregular or semi-transparent windows. In other embodiments, ADAS indication 904, regardless of color or shape, can be drawn either directly on the display of the desktop, or created as a separate graphical window by some process other than the target application window process. For example, ADAS indication 904 does not have to circumscribe target application window 902, but should be located in close proximity to target application window 902 to identify the semantic related to that application process or activity.
In still other embodiments, ADAS indication 904 can be a less obtrusive marker, e.g., a noticeable symbol, that does not outline target application window 902 in order to avoid cluttering the display of a desktop with too much information that may confuse users. For instance, for target application windows that are embedded in other windows, or smaller windows such as a toolbox, the less obtrusive marker can be used.
As described above, the scalability of ADAS indication 904 can be achieved using different colors, patterns, or animations for ADAS indication 904 around target application window 902 to differentiate varying types or semantics for different types of applications. For example, ADAS indication 904 can denote viewing of Internet content or email attachments by drawing a distinct, high-contrast animated outline. Other examples can include ADAS indication 904 denoting peer-to-peer interaction with corporate partners by drawing a distinct static, solid color outline. Thus, two ADAS indications can be drawn, each representing a different application semantic.
The ADAS indication techniques described herein provide a clear and distinct denotation that represents the segregation of multiple, and often simultaneous, roles users have thereby providing users a seamless manner to intuitively and with assurance perform activities in multiple contexts, e.g., within a DUAs. Thus, users can with assurance base their interactions on the context denoted by the ADAS—i.e., the end-users can interact with graphical windows assuredly knowing both the intent of their action and the effect they can expect.
Thus, a method and system for assured denotation of application semantics have been described. Although the above description discloses ADAS for graphical user-interaction areas (windows), the above ADAS techniques can work for any type of human interaction device. For example, in audio interaction systems, a particular distinct sound at the beginning and end of certain activity could delineate the application semantics of that particular activity using the techniques described above.
Furthermore, the present invention also relates to computer readable media that include program instruction or program code for performing various computer-implemented operations based on the methods of the present invention. The program instructions may be those specially designed and constructed for the purposes of the invention, or they may be of the kind well-known and available to those having skill in the computer software arts. Examples of program instructions include for example machine code, such as produced by a compiler, and files containing a high level code that can be executed by the computer using, for example, an interpreter or equivalent execution engine to facilitate execution of high level code. Alternative embodiments will become apparent to those skilled in the art to which the present invention pertains without departing from its spirit and scope. Accordingly, the scope of the present invention is defined by the appended claims rather than the foregoing description.
|Patente citada||Fecha de presentación||Fecha de publicación||Solicitante||Título|
|US5263147||1 Mar 1991||16 Nov 1993||Hughes Training, Inc.||System for providing high security for personal computers and workstations|
|US5377317||20 Dic 1991||27 Dic 1994||International Business Machines Corporation||Method and apparatus for distinctively displaying windows on a computer display screen|
|US5497484 *||24 Feb 1993||5 Mar 1996||Hewlett-Packard Company||File menu support for encapsulated applications|
|US5537548||14 Jun 1994||16 Jul 1996||International Business Machines Corporation||Method of computer conferencing by intercepting commands issued by application programs and redirecting to all stations for execution|
|US5564005 *||15 Oct 1993||8 Oct 1996||Xerox Corporation||Interactive system for producing, storing and retrieving information correlated with a recording of an event|
|US5619639||4 Oct 1994||8 Abr 1997||Mast; Michael B.||Method and apparatus for associating an image display area with an application display area|
|US5634102||7 Ago 1995||27 May 1997||Apple Computer, Inc.||Methods and apparatus for a selectable backdrop|
|US5673403||13 Nov 1992||30 Sep 1997||International Business Machines Corporation||Method and system for displaying applications of different operating systems on a single system using the user interface of the different operating systems|
|US5760769||22 Dic 1995||2 Jun 1998||Intel Corporation||Apparatus and method for identifying a shared application program in a computer during teleconferencing|
|US5761477||4 Dic 1995||2 Jun 1998||Microsoft Corporation||Methods for safe and efficient implementations of virtual machines|
|US5764985||27 Jun 1997||9 Jun 1998||Microsoft Corp||Notification mechanism for coordinating software extensions|
|US5790127||3 May 1996||4 Ago 1998||Intel Corporation||Supervising activations states in application sharing|
|US5828893||21 Ago 1995||27 Oct 1998||Motorola, Inc.||System and method of communicating between trusted and untrusted computer systems|
|US5832263||15 Mar 1996||3 Nov 1998||Digidox, Inc.||System and method for in-place modification of information recorded in read-only storage using modifiable non-volatile storage associated with an agent|
|US5845129||22 Mar 1996||1 Dic 1998||Philips Electronics North America Corporation||Protection domains in a single address space|
|US5913024||9 Feb 1996||15 Jun 1999||Secure Computing Corporation||Secure server utilizing separate protocol stacks|
|US5915085||28 Feb 1997||22 Jun 1999||International Business Machines Corporation||Multiple resource or security contexts in a multithreaded application|
|US5918018||9 Feb 1996||29 Jun 1999||Secure Computing Corporation||System and method for achieving network separation|
|US5956507||14 May 1996||21 Sep 1999||Shearer, Jr.; Bennie L.||Dynamic alteration of operating system kernel resource tables|
|US5974413 *||3 Jul 1997||26 Oct 1999||Activeword Systems, Inc.||Semantic user interface|
|US5974470||3 Sep 1997||26 Oct 1999||Chicago-Soft, Ltd.||System for reducing conflicts among dynamic link library modules by aliasing modules|
|US6014134 *||23 Ago 1996||11 Ene 2000||U S West, Inc.||Network-based intelligent tutoring system|
|US6023721||14 May 1997||8 Feb 2000||Citrix Systems, Inc.||Method and system for allowing a single-user application executing in a multi-user environment to create objects having both user-global and system global visibility|
|US6073157 *||7 Jun 1995||6 Jun 2000||International Business Machines Corporation||Program execution in a software run-time environment|
|US6167520||29 Ene 1997||26 Dic 2000||Finjan Software, Inc.||System and method for protecting a client during runtime from hostile downloadables|
|US6271839 *||2 Jul 1998||7 Ago 2001||Microsoft Corporation||Method and system for sharing applications between computer systems|
|US6323884||21 Jun 1999||27 Nov 2001||International Business Machines Corporation||Assisting user selection of graphical user interface elements|
|US6385724 *||30 Nov 1998||7 May 2002||Microsoft Corporation||Automatic object caller chain with declarative impersonation and transitive trust|
|US6415385 *||29 Jul 1998||2 Jul 2002||Unisys Corporation||Digital signaturing method and system for packaging specialized native files for open network transport and for burning onto CD-ROM|
|US6441833 *||29 Oct 1996||27 Ago 2002||Lucent Technologies Inc.||Dynamically specifying invocations in compiled objects|
|US6505300||12 Jun 1998||7 Ene 2003||Microsoft Corporation||Method and system for secure running of untrusted content|
|US6529985||4 Feb 2000||4 Mar 2003||Ensim Corporation||Selective interception of system calls|
|US6587888 *||15 Dic 1999||1 Jul 2003||Networks Associates Technology, Inc.||Dynamic software wrapper|
|US6657645 *||11 Jun 1999||2 Dic 2003||Microsoft Corporation||System, method, and computer-readable medium for displaying keyboard cues in a window|
|US6711579 *||20 Abr 2001||23 Mar 2004||Sree Ayyanar Spinning And Weaving Mills Limited||Data storage schema independent programming for data retrieval using semantic bridge|
|US6772168 *||7 May 2001||3 Ago 2004||Intergraph Software Technologies Company||Object relationship management system|
|US6772216 *||19 May 2000||3 Ago 2004||Sun Microsystems, Inc.||Interaction protocol for managing cross company processes among network-distributed applications|
|US6807636 *||13 Feb 2002||19 Oct 2004||Hitachi Computer Products (America), Inc.||Methods and apparatus for facilitating security in a network|
|US6865300 *||13 Abr 2004||8 Mar 2005||Nik Multimedia, Inc.||User definable image reference points|
|US7013289 *||21 Feb 2001||14 Mar 2006||Michel Horn||Global electronic commerce system|
|US7039875 *||30 Nov 2000||2 May 2006||Lucent Technologies Inc.||Computer user interfaces that are generated as needed|
|US7047232 *||13 Ene 1999||16 May 2006||Ab Initio Software Corporation||Parallelizing applications of script-driven tools|
|US7088871 *||3 Jun 2004||8 Ago 2006||Microsoft Corporation||Method and system for transmitting data for a shared application|
|US20020038451 *||9 Feb 2001||28 Mar 2002||Tanner Christopher C.||System and method for leveraging independent innovation in entertainment content and graphics hardware|
|US20020099952||8 Jun 2001||25 Jul 2002||Lambert John J.||Policies for secure software execution|
|US20020137507 *||20 Mar 2001||26 Sep 2002||Techimage, Llp.,||System and method for providing automatic multimedia messages service|
|US20020165912 *||25 Jul 2001||7 Nov 2002||Storymail, Inc.||Secure certificate and system and method for issuing and using same|
|US20020186245 *||19 Jul 2002||12 Dic 2002||Sundeep Chandhoke||System and method for configuring a hardware device to execute a prototype|
|US20030227483 *||10 Jun 2002||11 Dic 2003||Schultz Kevin L.||Displaying operations in an application using a graphical programming representation|
|US20030233544 *||14 Jun 2002||18 Dic 2003||Ulfar Erlingsson||Methods and systems for providing a secure application environment using derived user accounts|
|US20040006706 *||6 Jun 2003||8 Ene 2004||Ulfar Erlingsson||Methods and systems for implementing a secure application execution environment using derived user accounts for internet content|
|US20040093350 *||12 Nov 2002||13 May 2004||E.Piphany, Inc.||Context-based heterogeneous information integration system|
|1||Anurag Acharya et al., "MAPbox: Using Parameterized Behavior Classes to Confine Untrusted Applications," Proceedings of the 9<SUP>th </SUP>USENIX Security Symposium, Aug. 14-17, 2000, 17 pages.|
|2||Barry Boehm, "Managing Software Productivity and Reuse," University of Southern California, Sep. 1999, pp. 111-113.|
|3||David Evans et al. "Flexible Policy-Directed Code Safety," MIT Laboratory for Computer Science, IEEE, 1999, 14 pages.|
|4||Dennis M. Ritchie, "The Evolution of the Unix Time-Sharing System," Bell Labs, Lucent Technologies, 11 pages, no date.|
|5||Guy Edjlali et al., "History-based Access Control for Mobile Code," 5<SUP>th </SUP>Conference on Computer & Communications Security, 1998, pp. 38-48.|
|6||Ian Goldberg et al., "A Secure Environment for Untrusted Helper Applications (Confining the Wily Hacker)," Proceedings of the Sixth USENIX UNIX Security Symposium, Jul. 1996, 14 pages.|
|7||Jeremy Sugarman et al., "Virtualizing I/O Devices on Vmware Workstation's Hosted Virtual Machine Monitor," Proceedings of the 2001 UNSENIX Annual Technical Conference, Jun. 2001, 15 pages.|
|8||Jerome H. Salzter et al., "The Protection of Information in Computer Systems," Proceedings of the IEEE 63, Sep. 1975, 30 pages.|
|9||Manoj Lal et al., "A Scheduling Scheme for Controlling Allocation of CPU Resources for Mobile Programs," University of California, Davis, Aug. 31, 1999, pp. 1-33.|
|10||P. Deutsch et al., "A Flexible Measurement Tool for Software Systems," Information Processing (Proceedings of the IFIP Congress), 1972, pp. 320-326.|
|11||Robert P. Goldberg, "Survey of Virtual Machine Research," IEEE Computer, Jun. 1974, vol. 7, No. 6, pp. 34-45.|
|12||Robert Wahbe et al., "Efficient Software-Based Fault Isolation," Computer Science Division, University of California, SIGOPS, 1993, pp. 203-216.|
|13||Sotris Ioannidis, "Sub-Operating Systems: A New Approach to Application Security," 8 pages, no date.|
|14||Timothy Fraser et al. "Hardening COTS Software with Generic Software Wrappers," TIS Labs at Network Associates, Inc., IEEE, 1999, 15 pages.|
|15||Úlfar Erlingsson et al., "IRM Enforcement of Java Stack Inspection," IEEE, 2000, 10 pages.|
|16||Úlfar Erlingsson et al., "SASI Enforcement of Security Policies: A Retrospective," Department of Computer Science, Cornell University, pp. 87-95, no date.|
|Patente citante||Fecha de presentación||Fecha de publicación||Solicitante||Título|
|US7676810 *||3 Jun 2004||9 Mar 2010||Sap Ag||Identification of execution context|
|US7853669 *||4 May 2007||14 Dic 2010||Microsoft Corporation||Mesh-managing data across a distributed set of devices|
|US8364759 *||22 Oct 2010||29 Ene 2013||Microsoft Corporation||Mesh-managing data across a distributed set of devices|
|US8484174||20 Mar 2008||9 Jul 2013||Microsoft Corporation||Computing environment representation|
|US8572033||20 Mar 2008||29 Oct 2013||Microsoft Corporation||Computing environment configuration|
|US8938796||13 Sep 2013||20 Ene 2015||Paul Case, SR.||Case secure computer architecture|
|US9069750||30 Jun 2011||30 Jun 2015||Abbyy Infopoisk Llc||Method and system for semantic searching of natural language texts|
|US9075864||31 Dic 2010||7 Jul 2015||Abbyy Infopoisk Llc||Method and system for semantic searching using syntactic and semantic analysis|
|US9098489||30 Jun 2011||4 Ago 2015||Abbyy Infopoisk Llc||Method and system for semantic searching|
|US9122633||13 Ene 2015||1 Sep 2015||Paul Case, SR.||Case secure computer architecture|
|US9135279 *||20 Dic 2012||15 Sep 2015||Microsoft Technology Licensing, Llc||Mesh-managing data across a distributed set of devices|
|US20050273783 *||3 Jun 2004||8 Dic 2005||Tankov Nikolai D||Identification of execution context|
|US20110040850 *||22 Oct 2010||17 Feb 2011||Microsoft Corporation||Mesh-managing data across a distributed set of devices|
|US20130110801 *||20 Dic 2012||2 May 2013||Microsoft Corporation||Mesh-managing data across a distributed set of devices|
|Clasificación de EE.UU.||709/246|
|Clasificación internacional||G06F9/46, G06F9/44, G06F15/16, G09G5/00|
|1 May 2003||AS||Assignment|
Owner name: GREEN BORDER TECHNOLOGIES, INC., CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:ERLINGSSON, ULFAR;REEL/FRAME:014029/0216
Effective date: 20030411
|23 Oct 2007||AS||Assignment|
Owner name: GOOGLE INC.,CALIFORNIA
Free format text: MERGER;ASSIGNOR:GREEN BORDER TECHNOLOGIES, INC.;REEL/FRAME:019995/0713
Effective date: 20070511
|14 Feb 2012||FPAY||Fee payment|
Year of fee payment: 4
|14 Feb 2012||SULP||Surcharge for late payment|