Security requirement determination

In a managed code environment, a method implemented on a computing device having instructions stored on a computer-readable storage media and executable by a processor, comprising:

• simulating calling from one assembly to another for which a permission set is required, wherein the simulation comprises one or more simulated stack walks that include two or more of the assemblies, each assembly being managed code in a library, wherein an execution of each assembly is statically simulated without actually running a corresponding managed code to simulate all possible calls and corresponding flow of argument data, and wherein the simulated stack walk comprises:
• entering a public entry point of a method in the assembly;
• gathering a permission set for the method in the assembly;
• determining whether the method in the assembly calls another method in the assembly or in an another assembly;
• for each called method:
• gathering a permission set for the another method called by the method in the assembly;
• and
• determining whether the another method calls a subsequent method in the assembly or in the another assembly;
• and
• creating a union of the gathered permission sets;
• repeating the calling for each assembly in the managed code and for all possible execution paths of the managed code;
• repeating the entering for each public entry point in the library;
• finding the union of the permission sets corresponding to each call;
• and deriving security requirements for execution paths corresponding to the assemblies by using the union of the gathered permission sets across the execution paths corresponding to the one or more assemblies, wherein the union estimates the security requirements that will be triggered against the assemblies during an actual execution of the assemblies and whether a security exception will be triggered during the actual execution.

One or more computer storage media having a tangible component comprising instructions that, when executed by a processor, perform a static simulation of an execution of every data and control flow for managed code from which an estimate is derived of the minimum security requirements needed to dynamically execute the managed code without triggering a security exception, the instructions comprising:

• simulating, statically, one or more stack walks for each data and a control flow for the managed code, wherein the managed code corresponds to one or more assemblies, wherein the one or more stack walks comprise two or more of the assemblies, and
• finding a set of required permissions for each execution path by the stack walks, wherein each call in each execution path has a corresponding permissions set, wherein each assembly has one or more execution paths representing a different data and control flow, and wherein the simulated stack walk comprises:
• entering a public entry point of a method in an assembly;
• gathering a permission set for the method;
• determining whether the method calls another method;
• for each called method:
• gathering a permission set for the called method;
• and
• determining whether the called method calls a subsequent method;
• and
• creating a union of the gathered permission sets;
• and
• deriving the security requirements for execution paths corresponding to the two or more assemblies by using the union of the gathered permission sets, wherein the union estimates the security requirements that will be triggered against the two or more assemblies during an actual execution of the two or more assemblies.

An apparatus comprising:

• means for processing;
• means for storing information in memory coupled to the means for processing;
• virtual machine means, stored in the memory, in a managed code portion, for operating a plurality of assemblies in managed code, wherein the managed code is a managed shared library or an executable and is in the managed code portion;
• execution engine means, in a native code portion, for executing the virtual machine means;
• means, in the native code portion, for providing an operating system;
• means for making a call in the managed code portion for access by one assembly to another assembly for which a permissions set is required;
• means in the managed code portion for gathering the permissions set from each call;
• means in the managed code portion for deriving a union of the gathered permissions sets;
• means in the managed code portion for statically simulating the execution of all possible execution paths for the managed shared library or the executable without actually running a corresponding managed code, to derive therefrom the derived union of the gathered permissions sets wherein the means for simulating the execution performs, for each execution path, one or more simulated stack walks that each include a plurality of assemblies, and wherein the one or more simulated stack walks comprise:
• means for entering a public entry point of a method in the assembly;
• means for gathering a permission set for the method;
• means for determining whether the method calls another method;
• for each called method:
• means for gathering a permission set for the called method;
• means for determining whether the called method calls a subsequent method;
• means for repeating the previous gathering and determining until any gathered permission set is duplicative;
• and
• means for creating a union of the gathered permission sets;
• and
• means for deriving security requirements for execution paths corresponding to the plurality of assemblies by using the union of the gathered permission sets across the execution paths corresponding to the plurality of assemblies, wherein the union estimates whether a security exception will be triggered during an actual execution of the assemblies.

A computing device comprising:

• a processor;
• a memory coupled to the processor;
• a managed code portion stored in the memory;
• a native code portion stored in the memory;
• and
• an application program in the managed code portion comprising logic configured to:
• statically simulate the execution of all possible calls from one assembly to another assembly for all possible execution paths of the managed code without actually running a corresponding managed code to simulate all possible calls and corresponding flow of argument data, wherein each assembly call has a corresponding permissions set, wherein the simulation of the execution comprises one or more simulated stack walks that each include a plurality of assemblies, and wherein the one or more simulated stack walks comprise:
• a public entry point of a method in the assembly;
• a permission set for the method;
• a determination of whether the method calls another method;
• for each called method:
• a permission set for the called method;
• a determination of whether the called method calls a subsequent method;
• and
• a totality of permission sets such that any subsequent permission set is duplicative;
• and
• a union of the permission sets;
• derive a union of the permissions sets from each assembly call;
• and
• derive security requirements for execution paths corresponding to the plurality of assemblies by using the union of the permission sets across the execution paths corresponding to the plurality of assemblies, wherein the union estimates the security requirements that will be triggered against the one or more assemblies during an actual execution of the assemblies.