This chapter is from the book
This chapter is from the book
This chapter is from the book
.NET Security by Design
.NET security is targeted at developers. The .NET Framework provides a developer-centric and runtime security model on top of the Windows operating system security. It supports a role-based security that defines the access rights for resources using a role or a group. Role-based security addresses the security risk of broken access control for applications. At the software code level, the .NET Framework has Code Access Security, also known as evidence-based security, that defines whether or not a user can be trusted to access a resource. Code Access Security addresses the security risk of tampering or the use of a Trojan horse when downloading codes from external sources or Internet. Refer to [Watkins] for an overview of the .NET Framework security.
Figure 13-2 depicts a high-level security overview of the .NET Framework. The .NET Common Language Runtime (CLR) provides a runtime environment under the Windows hosting environment. When a .NET application is deployed, the .NET Framework assembles and deploys the .NET application to the target runtime environment in MSIL (Microsoft Intermediate Language) with the associated metadata. MSIL is an object- oriented assembly language that can be compiled to x86 native codes by a just-in-time compiler for execution in the CLR environment. metadata is a set of tables, also known as contract or blueprint, that depict the assembly’s types, their methods, fields, signatures, and dependencies on other assemblies.
The .NET Common Language Runtime also provides a runtime security system that uses a policy manager to evaluate what permission should be granted to a service request. A Principal interacts with a .NET application and issues a service request to access resources. The security system in the CLR evaluates the service request based on the evidence, which is a set of information that constitutes input to security policy decisions, for example, origin of the codes and digital signature of the assembly, in the Windows hosting environment and the security policies defined in the CLR’s policy levels and permission set.
)
Figure 13-2 .NET security overview
A .NET application is composed of an assembly and one or more .NET modules. An assembly is the unit of code deployment in the .NET Common Language Runtime environment. It consists of an assembly manifest (a list of the assembly layout and global attributes) and one or more .NET modules. .NET modules are either DLLs or EXE Windows portable executable files. They contain the Microsoft Intermediate Language (MSIL), the associated metadata, and optionally the assembly manifest.
In the .NET CLR environment, an assembly uses the basic permission set class System.Security.PermissionSet to grant permissions to codes that are defined in the policy levels of the security system. Permissions can be code access permissions, which protect the resources directly, or identity permissions, which represent evidence that is granted to assemblies.
A Principal authenticates with the Windows system and invokes a .NET application to access a system resource. The CLR environment evaluates the security policies to determine whether the Principal has appropriate permission and access rights to execute the program codes and access the system resources.
Code Access Security
Code Access Security (CAS) is a key security feature of .NET Framework. It supports the requirement that different code should have different levels of trust. Using CAS, the security access control is based on the identity of the code, not individual user identity (such as user id), who executes or runs the software codes. This addresses the limitation of access control for different software codes by username-password, which is at a coarse granularity level. For example, developers can define code access security policies to constrain the ability of an assembly to perform file input/output and restrict file input/output to a specific directory. Code access security addresses the insufficiency of guarding against malicious or faulty codes that may have been downloaded from e-mail or the Internet that can damage files, though the user has already been authenticated and authorized to run the executable codes. In other words, CAS addresses the gap of protection against malicious codes and is complementary to role-based security.
CAS has three key elements: evidence, security policy, and permissions. Evidence refers to the set of information that constitutes input to security policy decision. This includes the characteristics of an assembly, such as the Web site from where an assembly is loaded. Security policy (also refer to next section for details) is a set of rules used by the runtime policy resolution process, also known as the Policy Decision Point, to determine which permissions an assembly can be granted. Permissions refers to the authority of an assembly’s code to access protected operations and resources. There are three different permission classes in .NET: code-access permissions, for example, file input/output access granted to an assembly; identity permissions, where an assembly presents a certain host evidence value to the runtime policy resolution process as "identity;" and role-based permissions, when access is granted to a role, such as system administrator.
To illustrate how CAS works, consider a sample .NET application, "myinterop.exe," by re-using the architecture diagram in Figure 13-2. When a user runs the application "myinterop.exe," the .NET Common Language Runtime loads the "myinterop.exe" assembly from the Windows hosting environment. The runtime then evaluates its evidence and determines what permissions to grant the application against the defined security policies. For instance, the application, myinterop.exe, has a permission request to write to the text file "userpassword" in the local hard drive. The runtime’s policy resolution process determines what permission should be granted to the assembly based on the security policies as well as the permission set assigned to the assembly (for example, FileIOPermission object defined in the myinterop.exe assembly). Once the runtime confirms that the application has the necessary permission to write to the text file, "userpassword," the runtime responds with a positive result to the File.Write method. Otherwise, the runtime throws a System.Security.SecurityException if the permission is not granted.
CAS is about the understanding of the relationship between evidence, policies, and permission, the details of which are beyond the scope of this chapter. Please refer to the References section for more resources.
Security Policies
Security policies in the .NET Framework refer to the mechanism for administrators to express the level of trust for different codes. There are four key elements of the .NET security policies:
Membership conditions A membership condition resembles an object that answers "yes" or "no" when asked if an assembly matches its membership test. The membership conditions turn the evidence of an assembly into a grant set
Code groups Code groups map the .NET Framework code to specific levels of trust. They are bindings between membership conditions and permission sets. If code matches the membership condition in a code group, it is ranked a permission set.
Policy levels The System.Security.Policy.PolicyLevel class defines policy levels using a list of named permission sets, a code group hierarchy, and a list of "full trust" assemblies. There are four policy levels supported: enterprise, machine, user, and application domain. During the policy resolution of an assembly, the Policy Manager evaluates the assembly’s evidence against each individual policy level via the SecurityManager.ResolvePolicy method.
Default security policy This is the culmination of the default policies of all four policy levels, where each policy level has a hard-coded default. All default policy levels are identical with reference to the permission set lists and assembly lists. The permission set lists contain all the named permission sets.
Execution-Time Security
When an assembly is deployed to a target machine, the Assembly Loader loads the assembly in the CLR environment with the context of a trusted host, that is, the host is the trusted piece of code that is responsible to launch the runtime. The Policy Manager evaluates the current security policy, the evidence known about the assembly, and the set of permission requests, if any, made in the assembly metadata. It determines what permissions should be granted to the service requester based on the security policies for code access. Upon evaluation by the Policy Manager, the Class Loader loads the class for the JIT compiler to verify the codes prior to execution. The Code Manager then translates the classes into native code for execution.
Security Interoperability Features
.NET technology has provided several interoperability features to secure business applications. The following highlights a few major security interoperability features:
Support of WS-I Basic Security Profile 1.0 via Web Services Enhancement (WSE).
Support of single sign-on using Web SSO protocol via Active Directory Federation Services and the WS-MEX (metadata Exchange) protocol via Microsoft Windows Communication Foundation (WCF) or formerly Indigo.
Support of security interoperability standards, for example, OASIS’s Web Services Security.
Support of WS-Policy. WSE is an add-on to the .NET Framework and provides a policy editor that allows defining policies for Web services using WS-Policy.