|
SECURING AND DEPLOYING MICROSOFT.NET ASSEMBLIES (PRERELEASE)
Introduction
The goal of this three day instructor led course is to enable
developers to build Microsoft .NET compatible applications
by using assemblies, which are the basic unit of versioning,
isolation, security, and deployment in the .NET Framework
environment.
This course provides developers with a solid understanding
of how to develop and deploy private and shared assemblies.
It focuses on configuration, versioning, and security issues.
Topics include:
- Types of assemblies
- Side-by-side versioning in the global assembly cache
- MSI deployment using Microsoft Visual Studio® .NET
deployment projects
- Strong-name signing
- Code Access Security
- .NET role-based security
- Isolated storage
The course also includes an introduction to interoperation
between .NET components and Microsoft WIN32® code and
COM code.
Audience
This course is intended for experienced developers who will
be developing and deploying secure .NET applications. This
course is not intended for non-developers, nor is it intended
for developers who are unfamiliar with Microsoft tools and
technologies.
At Course Completion
At the end of the course, students will be able to:
- Define the term assembly, list the programming problems
that assemblies solve, and describe how code in an assembly
is executed.
- Describe the purpose of metadata and the manifest, and
their relationship to the .NET Framework.
- Create single-file and multi-file assemblies.
- Use code signing to create strong-named assemblies.
- Create Visual Studio .NET deployment projects to deploy
assemblies using the Microsoft Windows® Installer.
- Describe how type safety, verification, and strong-name
signing improve application security.
- Explain how the .NET security system uses policy to map
information about an assembly to a set of resource access
rights for an assembly.
- Use code access security to develop and use secure assemblies.
- Implement role-based security in an assembly by using
principals and identities, and create and use isolated storage.
- Call Win32 code and COM objects from assemblies.
Microsoft Certified Professional Exams
This course will help the student prepare for the following
Microsoft Certified Professional exam:
• There is no MCP exam associated with this course.
Prerequisites
Before attending this course, students must have:
- Attended Course 2349, Programming the Microsoft .NET Framework
with C#, or have a solid understanding of the .NET Framework.
- A basic skill level in C#, or a working knowledge of and
comfort with C++ syntax.
- A working knowledge of COM.
Course Outline
Module 1: Introduction To Assemblies
The following topics are covered in this module:
- The Programming Problems Assemblies Solve
- Assembly Concepts
At the end of this module, you will be able to define the
term assembly, list the programming problems that assemblies
solve, and describe how code in an assembly is executed. This
includes:
- Listing the programming problems that assemblies solve.
- Defining the term assembly.
- Describing the types of assemblies and differentiating
between strong-named assemblies and private assemblies.
- Describing how the code in an assembly is executed.
Module 2: Creating an Assembly
The following topics are covered in this module:
- Introduction to Metadata
- Creating, Packaging, and Referencing an Assembly
- Reflection
At the end of this module, you will be able to describe the
purpose of metadata and the manifest, and how these relate
to the .NET Framework, and create a single-file and a multi-file
assembly. This includes:
- Stating the purpose of metadata.
- Describing the contents found in the metadata that is
stored within an assembly or a portable executable (PE)
file.
- Using the Microsoft intermediate language (MSIL) Disassembler
to view the metadata stored within an assembly or a PE file.
- Creating a single-file assembly and a multi-file assembly.
- Describing the purpose of reflection and using it to inspect
metadata stored within an assembly.
Module 3: Deploying an Assembly
The following topics are covered in this module:
- Binding Policy and Configuration Files
- Types of Deployment
- Deploying Private Assemblies
- Deploying Strong-Named Assemblies
- Deployment Options
At the end of this module, you will be able to deploy private
and shared assemblies. This includes:
- Describing the purpose of binding policy.
- Describing the types of policy configuration files.
- Differentiating between private assemblies and strong-named
assemblies.
- Describing the purpose of the global assembly cache (GAC).
- Deploying and uninstalling private and strong-named assemblies.
- Describing the probing process for private assemblies.
- Listing the methods for deploying assemblies.
Module 4: Assembly Versioning and Satellite Assemblies
The following topics are covered in this module:
- Versioning
- Incremental Download
- Satellite Assemblies
At the end of this module, you will be able to explain assembly
versioning and deploy satellite assemblies. This includes:
- Explaining the need for versioning and describing how
versioning determines assembly compatibility.
- Configuring application binding policy and publisher binding
policy.
- Defining the terms side-by-side deployment and side-by-side
execution.
- Describing the probing process for strong-named assemblies.
- Listing benefits of using strong-named assemblies.
- Describing the incremental download deployment process
and listing some of its benefits.
- Describing the procedure that the common language runtime
uses to locate pieces of an assembly.
- Building an application for incremental download.
- Building a satellite assembly.
Module 5: Type Safety, Verification, and Code Signing
The following topics are covered in this module:
- Introduction to Security
- Type Safety and Verification
- Code Signing
- Cryptographic Services and Data Signing
At the end of this module, you will be able to describe how
type safety, verification, and strong-name signing improve
application security, and develop signed assemblies. This
includes:
- Explaining how the security model for the .NET Framework
relates to the security model for the Microsoft Windows
operating system.
- Describing how type safety and verification improve security.
- Explaining the benefits of code signing.
- Developing delay-signed assemblies.
- Describing the facilities in the .NET Framework for encrypting
and signing data.
Module 6: Code Access Security
The following topics are covered in this module:
- Evidence-Based Security
- Security Policy
- Imperative Code Access Security
- Declarative Code Access Security
- Miscellaneous Topics in Code Access Security
At the end of this module, you will be able to use code access
security to develop and secure assemblies. This includes:
- Listing and describing the kinds of evidence used by security
policy.
- Listing and describing built-in permissions and named
permission sets.
- Explaining how code groups fit into security policy.
- Describing how security policy is used to map evidence
to permission grants.
- Demanding and asserting permissions imperatively and
declaratively.
- Making assembly permission requests.
- Configuring security policy in the .NET Framework by using
the Microsoft Management Console (MMC) snap-in and the Code
Access Security Policy tool (Caspol.exe) for testing and
debugging purposes.
Module 7: Role Based Security and Isolated Storage
The following topics are covered in this module:
- Role-Based Security
- Creating Principals and Identities
- Performing Role-Based Security Checks
- Isolated Storage
- .NET Security Summary
At the end of this module, you will be able to implement role-based
security in an assembly by using principals and identities,
and create and use isolated storage. This includes:
- Describing the role-based security model of the .NET Framework.
- Creating principals and identities.
- Using the PrincipalPermission class to make role-based
security checks.
- Using the PrincipalPermissionAttribute attribute to make
role-based security checks.
- Using principal and identity objects directly to make
role-based security checks.
- Explaining the need for isolated storage.
- Creating and using isolated storage files.
Module 8: Interoperating Between Managed and Unmanaged Code
The following topics are covered in this module:
- Integration Services
- Platform Invoke
- Calling COM Objects from Managed Code
- Calling .NET Objects from COM Objects
At the end of this module, you will be able to interoperate
between .NET and unmanaged code. This includes:
- Stating the need for interoperability between .NET assemblies
and COM components.
- Using platform invoke to call a function in a dynamic-link
library (DLL).
- Exposing the methods and properties of a COM object to
an assembly.
- Describing the three ways to generate runtime callable
wrappers.
- Using Visual Studio .NET to call a COM object.
- Using the Type Library Importer to generate metadata from
a type library.
- Exposing the methods and properties of a .NET Framework
class to a COM client.
- Using the Type Library Exporter to generate a type library
for an assembly.
- Using the ClassInterface attribute to control and modify
the type of interface that is generated for a .NET Framework
class.
Inclusive to the overall costs of this Microsoft training
course is equipment, training material, lunch and refreshments.
|