Modification of compiled applications and application management using retrievable policies
A multi-component control technique includes a first component and a second component. The first component is supplemental code or evaluation engine as specified by a modification to a set of received originally compiled executable code. The modification to the original executable code ensures that, upon execution, the supplemental code (such as an evaluation engine) as specified by the modification is executed upon initial instantiation or use of the application. The second component is a retrievable and executable policy such as a set of rules fetched and used by the supplemental code to control the functionality supported by the originally compiled executable code of the corresponding application. An application administrator can produce the retrievable policy to control functionality of the originally compiled executable code.
1. A method comprising:
receiving a compiled application of original executable computer code;
modifying by a processor the compiled application to inject a new load command to load supplemental computer code with respect to the original executable computer code in the compiled application, the modified compiled application configured to execute the supplemental computer code with respect to the original executable computer code upon instantiation, the supplemental computer code coded to fetch, execute, and evaluate a policy of at least one rule in view of one or more particular types of data to be used to execute the at least one rule to control usage of functionality supported by the original executable computer code based on the at least one rule in the policy, wherein a mapping information is used to fetch the policy; and
providing access to the modified compiled application for installation of the modified compiled application on at least one host computer;
wherein the modifying includes:
verifying that the compiled application includes padding space of unused bits in which to insert the new load command, the padding space disposed between respective existing load commands in the received compiled application and subsequent data sections in the received compiled application;
inserting the new load command into the padding space, the new load command pointing to the supplemental computer code to be injected into the original executable computer code upon the instantiation of the modified compiled application;
modifying a header in the received compiled application, the header defining attributes of the compiled application, the header modified to indicate a change to a number of load commands to be executed upon the instantiation of the modified compiled application, the change indicating to execute the respective existing load commands in the received compiled application and the new load command inserted into the padding space;
receiving the supplemental computer code; and
adding the supplemental computer code to the original executable computer code.
2. the method as in claim 1 , wherein the supplemental code is coded to evaluate the at least one rule in the policy in view of settings of corresponding status information pertaining to the at least one rule.
3. The method as in claim 1 , wherein the policy includes executable code to be executed by the supplemental computer code.
4. The method as in claim 1 , wherein the supplemental code is coded to retrieve the policy from a remote resource over a server in a network and store a copy of the policy in a cache of a respective host computer on which the modified compiled application is installed; and
wherein an administrator produces the policy to include multiple rules specifying conditions of using the functionality supported by the original executable computer code.
5. The method as in claim 4 , wherein the supplemental code is coded to attempt retrieval of the policy from the cache.
6. The method as in claim 1 , wherein the supplemental code is coded to obtain unique identity information of a user initiating execution of the modified compiled application and transmit the unique identity information to a server that stores the policy, an administrator producing the policy to control usage of the functionality by the user.
7. The method as in claim 1 , wherein the supplemental code is an evaluation engine function coded to perform an evaluation of whether to allow use of specific functionality supported by the original executable computer code in response to an attempt by a user to execute the specific functionality.
8. The method as in claim 1 , wherein modifying the compiled application to include the new load command further comprises:
replacing an original existing load command in the received compiled application with the new load command to load the supplemental computer code upon the instantiation.
9. The method as in claim 8 , wherein the original existing load command indicated to load the original executable computer code in the compiled application, the method further comprising:
configuring the supplemental computer code to load the original executable computer code in the compiled application upon the instantiation of the modified compiled application.
10. The method as in claim 1 , wherein the new load command specifies to load a respective library upon the instantiation of the modified compiled application, the respective library including the supplemental computer code.
11. The method as in claim 1 , wherein the policy is a first policy; and
wherein the supplemental computer code is operable to retrieve a second policy in response to detecting that the first policy is no longer usable, the second policy being a substitute for the first policy.
12. The method as in claim 1 , wherein the policy is a first policy assigned expiry information indicating when the first policy is no longer valid; and
wherein the supplemental computer code is operable to retrieve a second policy to replace the first policy in response to detecting that the expiry information indicates that the first policy is no longer valid.
13. The method as in claim 1 , wherein the supplemental computer code is operable to prevent further use of the policy and the modified compiled application upon detection of a predetermined event.
14. A system comprising: a host computer processor hardware; and
computer instructions executed by the host computer processor hardware to perform operations of:
receiving a compiled application of original executable computer code;
modifying the compiled application to inject a new load command to load supplemental computer code with respect to the original executable computer code in the compiled application, the modified compiled application configured to execute the supplemental computer code with respect to the original executable computer code upon instantiation, the supplemental computer code coded to fetch, execute, and evaluate a policy of a set of rules in view of one or more particular types of data to be used to execute the set of rules to control usage of functionality supported by the original executable computer code based on the at least one rule in the policy, wherein a mapping information is used to fetch the policy; and
providing access to the modified compiled application for installation of the modified compiled application on at least one host computer;
wherein the modifying includes:
verifying that the compiled application includes padding space of unused bits in which to insert the new load command, the padding space disposed between respective existing load commands in the received compiled application and subsequent data sections in the received compiled application;
inserting the new load command into the padding space, the new load command pointing to the supplemental computer code to be injected into the original executable computer code upon the instantiation of the modified compiled application;
modifying a header in the received compiled application, the header defining attributes of the compiled application, the header modified to indicate a change to a number of load commands to be executed upon the instantiation of the modified compiled application, the change indicating to execute the respective existing load commands in the received compiled application and the new load command inserted into the padding space;
receiving the supplemental computer code; and adding the supplemental computer code to the original executable computer code.
15. The system as in claim 14 , wherein the supplemental computer code is an evaluation engine that executes the policy to control usage of functions supported by the originally compiled code; and
the evaluation engine coded to obtain data as specified by the set of rules in the policy and generate control decisions for the functions based on processing of the set of rules using the obtained data.
16. The system as in claim 14 , wherein the supplemental computer code is coded to retrieve the policy as executable computer code from a remote server resource over a network and execute the computer code in the retrieved policy to control usage of the functions supported by the originally compiled code.
17. The system as in claim 14 , wherein the supplemental computer code is coded to:
obtain unique identity information of a user initiating execution of the modified compiled application on the host computer processor hardware,
transmit the unique identity information to a server that stores the policy, an application administrator producing the policy to control usage of the functionality by the user, and
receive the policy from the server, the policy customized to control use of the functionality by the user.
18. The system as in claim 14 , wherein the supplemental code is an evaluation engine coded to perform an evaluation of whether to allow use of specific functionality supported by the originally compiled code on the host computer processor hardware in response to an attempt by a user of the host computer to execute the specific functionality.
19. A computer-readable hardware storage medium having instructions stored thereon for processing data information, such
that the instructions, when carried out by a processing device, cause the processing device to perform operations of:
receiving a compiled application of original executable computer code;
modifying the compiled application to inject a new load command to load supplemental computer code with respect to the original executable computer code in the compiled application, the modified compiled application configured to execute the supplemental computer code with respect to the original executable computer code upon instantiation, the supplemental computer code coded to fetch, execute, and evaluate a policy of a set of rules in view of one or more particular types of data to be used to execute the set of rules to control usage of functionality supported by the original executable computer code based on the at least one rule in the policy, wherein a mapping information is used to fetch the policy; and
providing access to the modified compiled application for installation of the modified compiled application on at least one host computer;
wherein the modifying includes:
verifying that the compiled application includes padding space of unused bits in which to insert the new load command, the padding space disposed between respective existing load commands in the received compiled application and subsequent data sections in the received compiled application;
inserting the new load command into the padding space, the new load command pointing to the supplemental computer code to be injected into the original executable computer code upon the instantiation of the modified compiled application;
modifying a header in the received compiled application, the header defining attributes of the compiled application, the header modified to indicate a change to a number of load commands to be executed upon the instantiation of the modified compiled application, the change indicating to execute the respective existing load commands in the received compiled application and the new load command inserted into the padding space;
receiving the supplemental computer code; and
adding the supplemental computer code to the original executable computer code.