Programming .NET Security Adam Freeman, Allen Jones

Spis treści książki

• Programming .NET Security
  • SPECIAL OFFER: Upgrade this ebook with OReilly
  • A Note Regarding Supplemental Files
  • Preface
    • How This Book Is Organized
      • Part I: Fundamentals
      • Part II: .NET Security
      • Part III: .NET Cryptography
      • Part IV: .NET Applications Frameworks
      • Part V: API Quick Reference
    • Who Should Read This Book
    • Assumptions This Book Makes
    • Conventions Used in This Book
    • How to Contact Us
  • I. Fundamentals
    • 1. Security Fundamentals
      • 1.1. The Need for Security
      • 1.2. Roles in Security
        • 1.2.1. The Business Sponsor
        • 1.2.2. The Architect
        • 1.2.3. The Programmer
        • 1.2.4. The Security Tester
        • 1.2.5. The System Administrator
        • 1.2.6. The User
        • 1.2.7. The Hacker/Cracker
      • 1.3. Understanding Software Security
        • 1.3.1. Restricted Resources
        • 1.3.2. Trust
        • 1.3.3. Secrets
          • 1.3.3.1. The lifetime of secrets
          • 1.3.3.2. Protecting secrets
      • 1.4. End-to-End Security
        • 1.4.1. Real-World Trust Relationships
        • 1.4.2. Side Channels
        • 1.4.3. Physical Security
        • 1.4.4. Third-Party Software
    • 2. Assemblies
      • 2.1. Assemblies Explained
      • 2.2. Creating Assemblies
        • 2.2.1. Creating a Single-File Assembly
        • 2.2.2. Creating a Multifile Assembly
      • 2.3. Shared Assemblies
      • 2.4. Strong Names
        • 2.4.1. Creating a Key Pair
        • 2.4.2. Creating an Assembly Strong Name
          • 2.4.2.1. Specifying the version and culture metadata
          • 2.4.2.2. Specifying the key pair
          • 2.4.2.3. Creating the strong name
          • 2.4.2.4. Creating a strong name for a multifile assembly
        • 2.4.3. Delayed Signing
        • 2.4.4. Verifying a Strong Name
      • 2.5. Publisher Certificates
        • 2.5.1. Using the Global Assembly Cache
      • 2.6. Decompiling Explained
        • 2.6.1. Decompiling Assemblies
        • 2.6.2. Protecting Against Decompilation
          • 2.6.2.1. Obfuscation
          • 2.6.2.2. Native compilation
    • 3. Application Domains
      • 3.1. Application Domains Explained
        • 3.1.1. Application Isolation in the .NET Framework
        • 3.1.2. Application Domain and Assembly Management
        • 3.1.3. Assembly Isolation with Application Domains
        • 3.1.4. Application Domains and Runtime Security
          • 3.1.4.1. Assembly evidence and identity
          • 3.1.4.2. Application domain evidence and identity
          • 3.1.4.3. Application domains and security policy
          • 3.1.4.4. Role-based security
          • 3.1.4.5. Application domains and isolated storage
        • 3.1.5. Application Domains and Application Configuration
    • 4. The Lifetime of a Secure Application
      • 4.1. Designing a Secure .NET Application
        • 4.1.1. Identifying Restricted Resources
        • 4.1.2. Identifying Trust
        • 4.1.3. Identifying Secrets
        • 4.1.4. Failing Gracefully
      • 4.2. Developing a Secure .NET Application
      • 4.3. Security Testing a .NET Application
      • 4.4. Deploying a .NET Application
      • 4.5. Executing a .NET Application
      • 4.6. Monitoring a .NET Application
  • II. .NET Security
    • 5. Introduction to Runtime Security
      • 5.1. Runtime Security Explained
        • 5.1.1. Running Unverifiable and Native Code
      • 5.2. Introducing Role-Based Security
      • 5.3. Introducing Code-Access Security
        • 5.3.1. Evidence, Security Policy, and Permissions
        • 5.3.2. Windows Security and Code-Access Security
      • 5.4. Introducing Isolated Storage
    • 6. Evidence and Code Identity
      • 6.1. Evidence Explained
        • 6.1.1. Sources and Types of Evidence
          • 6.1.1.1. Host evidence
          • 6.1.1.2. Assembly evidence
      • 6.2. Programming Evidence
        • 6.2.1. Introduction to Evidence Programming
        • 6.2.2. Using the Evidence Class
        • 6.2.3. Using the Standard Evidence Classes
          • 6.2.3.1. The ApplicationDirectory class
          • 6.2.3.2. The Hash class
          • 6.2.3.3. The Publisher class
          • 6.2.3.4. The Site class
          • 6.2.3.5. The StrongName class
          • 6.2.3.6. The Url class
          • 6.2.3.7. The Zone class
        • 6.2.4. Viewing Evidence
        • 6.2.5. Assigning Evidence to Assemblies
        • 6.2.6. Assigning Evidence to Application Domains
      • 6.3. Extending the .NET Framework
        • 6.3.1. Creating Custom Evidence
          • 6.3.1.1. Defining the Author evidence class
          • 6.3.1.2. Using the SecurityElement Class
          • 6.3.1.3. Building the Author evidence class
        • 6.3.2. Using Custom Evidence
          • 6.3.2.1. Making the Author assembly a fully trusted assembly
          • 6.3.2.2. Serializing evidence
          • 6.3.2.3. Embedding evidence in an assembly
        • 6.3.3. The Next Steps in Customization
    • 7. Permissions
      • 7.1. Permissions Explained
        • 7.1.1. Granting Permissions
        • 7.1.2. Requesting Permissions
        • 7.1.3. Permission Types
          • 7.1.3.1. Code-access permissions
          • 7.1.3.2. Identity permissions
        • 7.1.4. Enforcing Code-Access Security
          • 7.1.4.1. Stack walks explained
      • 7.2. Programming Code-Access Security
        • 7.2.1. Security Statement Syntax
          • 7.2.1.1. Imperative security statements
          • 7.2.1.2. Declarative security statements
        • 7.2.2. Programming Permissions
          • 7.2.2.1. Common permission class functionality
          • 7.2.2.2. Using the SecurityPermission class
        • 7.2.3. Programming Permission Sets
        • 7.2.4. Programming Permission Requests
          • 7.2.4.1. Requesting minimum permission
          • 7.2.4.2. Requesting optional permissions
          • 7.2.4.3. Refusing permissions
        • 7.2.5. Programming Permission Demands
          • 7.2.5.1. Demand
          • 7.2.5.2. LinkDemands
          • 7.2.5.3. Inheritance demands
        • 7.2.6. Manipulating Stack Walks
          • 7.2.6.1. Assert
          • 7.2.6.2. Deny
          • 7.2.6.3. PermitOnly
          • 7.2.6.4. Reverting overrides
      • 7.3. Extending the .NET Framework
        • 7.3.1. Creating Custom Code-Access Permissions
          • 7.3.1.1. Designing the RadioPermission class
          • 7.3.1.2. Defining imports and assembly scope attributes
          • 7.3.1.3. Defining the RadioAction enumeration
          • 7.3.1.4. Defining the RadioPermission class
          • 7.3.1.5. Implementing the IUnrestrictedPermission interface
          • 7.3.1.6. Implementing the IPermission interface
          • 7.3.1.7. Implementing the ISecurityEncodable interface
          • 7.3.1.8. Defining the RadioPermissionAttribute class
          • 7.3.1.9. Building the Radio.dll library
          • 7.3.1.10. Using RadioPermission to enforce security
    • 8. Security Policy
      • 8.1. Security Policy Explained
        • 8.1.1. Security Policy Levels
          • 8.1.1.1. Code groups
          • 8.1.1.2. Named permission sets
          • 8.1.1.3. Fully trusted assemblies
        • 8.1.2. Policy Resolution
          • 8.1.2.1. Code group attributes
        • 8.1.3. Configuring Security Policy
      • 8.2. Programming Security Policy
        • 8.2.1. Programming Code Groups
          • 8.2.1.1. Programming membership conditions
          • 8.2.1.2. Programming policy statements
          • 8.2.1.3. Creating code groups
        • 8.2.2. Programming Policy Levels
          • 8.2.2.1. Managing fully trusted assemblies
          • 8.2.2.2. Managing named permission sets
          • 8.2.2.3. Managing the code group tree
        • 8.2.3. Programming the Security Manager
        • 8.2.4. Programming Application Domain Policy
      • 8.3. Extending the .NET Framework
        • 8.3.1. Custom Membership Conditions Explained
        • 8.3.2. Defining the AuthorMembershipCondition Class
        • 8.3.3. Building the AuthorMembershipCondition Assembly
        • 8.3.4. Using the AuthorMembershipCondition Membership Condition
          • 8.3.4.1. Installing security assemblies
          • 8.3.4.2. Generating AuthorMembershipCondition XML
          • 8.3.4.3. Configuring security policy
        • 8.3.5. Testing Custom Membership Conditions
    • 9. Administering Code-Access Security
      • 9.1. Default Security Policy
        • 9.1.1. Security Policy Files
        • 9.1.2. Named Permission Sets
        • 9.1.3. Enterprise and User Policy Code Groups
        • 9.1.4. Machine Policy Code Groups
        • 9.1.5. Fully Trusted Assemblies
      • 9.2. Inspecting Declarative Security Statements
      • 9.3. Using the .NET Framework Configuration Tool
        • 9.3.1. Managing Fully Trusted Assemblies
          • 9.3.1.1. Adding a fully trusted assembly
          • 9.3.1.2. Deleting a fully trusted assembly
        • 9.3.2. Managing Named Permission Sets
          • 9.3.2.1. Creating named permission sets
        • 9.3.3. Managing Code Groups
          • 9.3.3.1. Creating code groups
        • 9.3.4. Other Security Policy Administration Options
      • 9.4. Using the Code-Access Security Policy Tool
        • 9.4.1. Controlling the Security System
          • 9.4.1.1. Switching code-access security on and off
          • 9.4.1.2. Switching execution permission checks on and off
        • 9.4.2. Administering Policy Levels
          • 9.4.2.1. Specifying the target policy level
          • 9.4.2.2. Specifying the target code group
          • 9.4.2.3. Managing fully trusted assemblies
          • 9.4.2.4. Managing named permission sets
          • 9.4.2.5. Managing code groups
        • 9.4.3. Evaluating Security Policy
        • 9.4.4. Forcing Security Changes
        • 9.4.5. Resetting Security Policy
    • 10. Role-Based Security
      • 10.1. Role-Based Security Explained
        • 10.1.1. .NET Role-Based Security Explained
        • 10.1.2. Comparing .NET Role-Based Security and Windows Security
      • 10.2. Programming Role-Based Security
        • 10.2.1. Introducing the IIdentity and IPrincipal Interfaces
        • 10.2.2. Determining the Current Principal
        • 10.2.3. Programming the Windows Role-Based Security Implementation
          • 10.2.3.1. Configuring the current WindowsPrincipal
          • 10.2.3.2. Impersonating Windows users
        • 10.2.4. Making Role-Based Security Demands
          • 10.2.4.1. Using imperative role-based security statements
          • 10.2.4.2. Using declarative role-based security statements
        • 10.2.5. Programming the Generic Role-Based Security Implementation
          • 10.2.5.1. Configuring the current GenericPrincipal
    • 11. Isolated Storage
      • 11.1. Isolated Storage Explained
        • 11.1.1. Levels of Isolation
          • 11.1.1.1. Determining user and code identity
          • 11.1.1.2. Isolation by user and assembly
          • 11.1.1.3. Isolation by user, assembly, and application domain
        • 11.1.2. Limitations of Isolated Storage
      • 11.2. Programming Isolated Storage
        • 11.2.1. Isolated Storage and Code-Access Security
        • 11.2.2. Obtaining a Store
        • 11.2.3. Creating Directories
        • 11.2.4. Creating, Reading, and Writing Files
        • 11.2.5. Searching for Files and Directories
        • 11.2.6. Deleting Files and Directories
        • 11.2.7. Deleting Stores
      • 11.3. Administering Isolated Storage
        • 11.3.1. Configuring Security Policy
          • 11.3.1.1. Granting isolated storage permissions with Mscorcfg.msc
          • 11.3.1.2. Granting isolated storage permissions with Caspol.exe
        • 11.3.2. Managing Isolated Storage Stores
  • III. .NET Cryptography
    • 12. Introduction to Cryptography
      • 12.1. Cryptography Explained
        • 12.1.1. Confidentiality
        • 12.1.2. Integrity
        • 12.1.3. Authentication
      • 12.2. Cryptography Is Key Management
      • 12.3. Cryptographic Attacks
        • 12.3.1. Brute Force Attacks, Theft, and Guessing
        • 12.3.2. Cryptanalysis
        • 12.3.3. Software Bugs
    • 13. Hashing Algorithms
      • 13.1. Hashing Algorithms Explained
        • 13.1.1. Creating a Hash Code
        • 13.1.2. Message Limits
        • 13.1.3. Hash Code Length
        • 13.1.4. The .NET Framework Hashing Algorithms
      • 13.2. Programming Hashing Algorithms
        • 13.2.1. The HashAlgorithm Class
        • 13.2.2. Instantiating the Algorithm
        • 13.2.3. Hashing Data from Memory
        • 13.2.4. Hashing Streamed Data
        • 13.2.5. Validating Hash Codes
      • 13.3. Keyed Hashing Algorithms Explained
        • 13.3.1. Creating the Keyed Hash Code
          • 13.3.1.1. HMAC algorithms
          • 13.3.1.2. Block cipher hash codes
        • 13.3.2. The .NET Framework Keyed Hashing Algorithms
      • 13.4. Programming Keyed Hashing Algorithms
        • 13.4.1. The KeyedHashAlgorithm Class
        • 13.4.2. Instantiating the Algorithm
        • 13.4.3. Hashing Data and Validating Hash Codes
      • 13.5. Extending the .NET Framework
        • 13.5.1. The Alder32 Algorithm Explained
        • 13.5.2. Defining the Abstract Class
        • 13.5.3. Defining the Implementation Class
          • 13.5.3.1. Creating the implementation class
          • 13.5.3.2. Implementing the Initialize method
          • 13.5.3.3. Implementing the HashCore and HashFinal methods
          • 13.5.3.4. Completing the class
          • 13.5.3.5. Testing the implementation
    • 14. Symmetric Encryption
      • 14.1. Encryption Revisited
      • 14.2. Symmetric Encryption Explained
        • 14.2.1. Creating the Encrypted Data
        • 14.2.2. Cipher Modes
          • 14.2.2.1. Electronic Codebook mode
          • 14.2.2.2. Cipher block chaining
          • 14.2.2.3. Cipher feedback mode
        • 14.2.3. Block Padding
        • 14.2.4. Symmetric Encryption Key Lengths
        • 14.2.5. The .NET Framework Encryption Algorithms
      • 14.3. Programming Symmetrical Encryption
        • 14.3.1. The SymmetricAlgorithm Class
        • 14.3.2. Instantiating the Algorithm
        • 14.3.3. Configuring the Algorithm
          • 14.3.3.1. Block and key sizes
          • 14.3.3.2. Cipher and padding modes
          • 14.3.3.3. Keys and initialization vectors (IVs)
        • 14.3.4. Encrypting and Decrypting Data
      • 14.4. Extending the .NET Framework
        • 14.4.1. The Extended Tiny Encryption Algorithm Explained
        • 14.4.2. Defining the Abstract Class
        • 14.4.3. Defining the Implementation Class
        • 14.4.4. Defining an Abstract Transformation
        • 14.4.5. Defining the Encryption Transformation
        • 14.4.6. Defining the Decryption Transformation
    • 15. Asymmetric Encryption
      • 15.1. Asymmetric Encryption Explained
        • 15.1.1. Creating Asymmetric Keys
        • 15.1.2. Asymmetric Algorithm Security
        • 15.1.3. Creating the Encrypted Data
          • 15.1.3.1. Asymmetric data padding
      • 15.2. Programming Asymmetrical Encryption
        • 15.2.1. The AsymmetricAlgorithm class
        • 15.2.2. The RSA class
        • 15.2.3. The RSACryptoServiceProvider Class
        • 15.2.4. Instantiating the Algorithm
        • 15.2.5. Using RSA Keys
        • 15.2.6. Encrypting and Decrypting Data
      • 15.3. Extending the .NET Framework
        • 15.3.1. The ElGamal Algorithm Explained
          • 15.3.1.1. ElGamal key generation protocol
          • 15.3.1.2. ElGamal encryption and decryption functions
        • 15.3.2. Processing Large Integer Values
        • 15.3.3. Defining the Abstract Class
        • 15.3.4. Defining the Implementation Class
        • 15.3.5. Defining the Abstract Cipher Function Class
        • 15.3.6. Defining the Encryption Class
        • 15.3.7. Defining the Decryption Class
        • 15.3.8. Testing the Algorithm
    • 16. Digital Signatures
      • 16.1. Digital Signatures Explained
        • 16.1.1. Digital Signature Security
        • 16.1.2. The .NET Framework Digital Signature Algorithms
        • 16.1.3. Creating Digital Signatures
      • 16.2. Programming Digital Signatures
        • 16.2.1. Using the Abstract Class
        • 16.2.2. Using the Implementation Class
        • 16.2.3. Using the Signature Formatter Classes
      • 16.3. Programming XML Signatures
        • 16.3.1. XMLDSIG Explained
        • 16.3.2. Signing an XML Document
          • 16.3.2.1. Creating the reference
          • 16.3.2.2. Creating the SignedXML
          • 16.3.2.3. Setting the signing algorithm
          • 16.3.2.4. Creating the signature
        • 16.3.3. Embedding Objects in the Signature
        • 16.3.4. Verifying an XML Signature
      • 16.4. Extending the .NET Framework
        • 16.4.1. The ElGamal Signature Functions Explained
        • 16.4.2. Defining the Signature Function Class
        • 16.4.3. Implementing the Managed Class Methods
        • 16.4.4. Defining the PKCS #1 Helper Class
        • 16.4.5. Defining the Signature Formatter Class
        • 16.4.6. Defining the Signature Deformatter Class
        • 16.4.7. Testing the Algorithm
    • 17. Cryptographic Keys
      • 17.1. Cryptographic Keys Explained
        • 17.1.1. Understanding Key Complexity
        • 17.1.2. Exchanging Symmetric Algorithm Keys
      • 17.2. Programming Cryptographic Keys
        • 17.2.1. Creating Keys
          • 17.2.1.1. Using the algorithm classes
          • 17.2.1.2. Using a random number generator
          • 17.2.1.3. Using a key-derivation protocol
        • 17.2.2. Using Key Persistence
        • 17.2.3. Key Exchange Formatting
      • 17.3. Extending the .NET Framework
        • 17.3.1. ElGamal Key Exchange Explained
        • 17.3.2. Defining the Key Exchange Formatter
        • 17.3.3. Defining the Key Exchange Deformatter
  • IV. .NET Application Frameworks
    • 18. ASP.NET Application Security
      • 18.1. ASP.NET Security Explained
        • 18.1.1. ASP.NET Security Overview
        • 18.1.2. ASP.NET Configuration Files
          • 18.1.2.1. ASP.NET security-related configuration elements
          • 18.1.2.2. Using <location> elements
      • 18.2. Configuring the ASP.NET Worker Process Identity
      • 18.3. Authentication
        • 18.3.1. Configuring IIS Authentication Modes
        • 18.3.2. No Authentication
        • 18.3.3. Windows Authentication
        • 18.3.4. Forms Authentication
          • 18.3.4.1. Configuring Forms authentication
          • 18.3.4.2. Creating the logon page
          • 18.3.4.3. Creating the protected page
        • 18.3.5. Passport Authentication
      • 18.4. Authorization
        • 18.4.1. File Authorization
        • 18.4.2. URL Authorization
      • 18.5. Impersonation
      • 18.6. ASP.NET and Code-Access Security
    • 19. COM+ Security
      • 19.1. COM+ Security Explained
        • 19.1.1. COM+ Role-Based Security
        • 19.1.2. COM+ Process-Access Security
          • 19.1.2.1. Authentication
          • 19.1.2.2. Impersonation
      • 19.2. Programming COM+ Security
        • 19.2.1. Creating the Serviced Component
        • 19.2.2. Specifying the COM+ Application Type
        • 19.2.3. Applying the Security Attributes
          • 19.2.3.1. The ApplicationAccessControl attribute
          • 19.2.3.2. The ComponentAccessControl Attribute
          • 19.2.3.3. The SecurityRole attribute
          • 19.2.3.4. The SecureMethod attribute
        • 19.2.4. Compiling and Installing the COM+ Application
      • 19.3. Administering COM+ Security
        • 19.3.1. Viewing the COM+ Catalogue
        • 19.3.2. Populating COM+ Application Roles
        • 19.3.3. Assessing and Assigning Role Scope
        • 19.3.4. Managing COM+ Security
          • 19.3.4.1. Managing the application
          • 19.3.4.2. Managing the component
    • 20. The Event Log Service
      • 20.1. The Event Log Service Explained
        • 20.1.1. Event Logs
        • 20.1.2. Event Sources
        • 20.1.3. Event Structure
          • 20.1.3.1. Event source name
          • 20.1.3.2. Message
          • 20.1.3.3. Event type
          • 20.1.3.4. Event identifier and event category
          • 20.1.3.5. Binary data
      • 20.2. Programming the Event Log Service
        • 20.2.1. Querying the Event Log System
        • 20.2.2. Using Event Sources
        • 20.2.3. Reading Event Logs
        • 20.2.4. Writing Events
        • 20.2.5. Using Custom Event Logs
        • 20.2.6. Monitoring Event Logs
  • V. API Quick Reference
    • 21. How to Use This Quick Reference
      • 21.1. Finding a Quick-Reference Entry
      • 21.2. Reading a Quick-Reference Entry
        • 21.2.1. Type Name, Namespace, Assembly, Type Category, and Flags
        • 21.2.2. Description
        • 21.2.3. Synopsis
          • 21.2.3.1. Member availability and flags
          • 21.2.3.2. Functional grouping of members
        • 21.2.4. Class Hierarchy
        • 21.2.5. Cross-References
        • 21.2.6. A Note About Type Names
    • 22. Converting from C# to VB Syntax
      • 22.1. General Considerations
      • 22.2. Classes
      • 22.3. Structures
      • 22.4. Interfaces
      • 22.5. Class, Structure, and Interface Members
        • 22.5.1. Fields
        • 22.5.2. Methods
        • 22.5.3. Properties
        • 22.5.4. Events
      • 22.6. Delegates
      • 22.7. Enumerations
    • 23. The System.Security Namespace
      • AllowPartiallyTrustedCallersAttribute
      • CodeAccessPermission
      • IEvidenceFactory
      • IPermission
      • ISecurityEncodable
      • ISecurityPolicyEncodable
      • IStackWalk
      • NamedPermissionSet
      • PermissionSet
      • PolicyLevelType
      • SecurityElement
      • SecurityException
      • SecurityManager
      • SecurityZone
      • SuppressUnmanagedCodeSecurityAttribute
      • UnverifiableCodeAttribute
      • VerificationException
      • XmlSyntaxException
    • 24. The System.Security.Cryptography Namespace
      • AsymmetricAlgorithm
      • AsymmetricKeyExchangeDeformatter
      • AsymmetricKeyExchangeFormatter
      • AsymmetricSignatureDeformatter
      • AsymmetricSignatureFormatter
      • CipherMode
      • CryptoAPITransform
      • CryptoConfig
      • CryptographicException
      • CryptographicUnexpectedOperationException
      • CryptoStream
      • CryptoStreamMode
      • CspParameters
      • CspProviderFlags
      • DeriveBytes
      • DES
      • DESCryptoServiceProvider
      • DSA
      • DSACryptoServiceProvider
      • DSAParameters
      • DSASignatureDeformatter
      • DSASignatureFormatter
      • FromBase64Transform
      • FromBase64TransformMode
      • HashAlgorithm
      • HMACSHA1
      • ICryptoTransform
      • KeyedHashAlgorithm
      • KeySizes
      • MACTripleDES
      • MaskGenerationMethod
      • MD5
      • MD5CryptoServiceProvider
      • PaddingMode
      • PasswordDeriveBytes
      • PKCS1MaskGenerationMethod
      • RandomNumberGenerator
      • RC2
      • RC2CryptoServiceProvider
      • Rijndael
      • RijndaelManaged
      • RNGCryptoServiceProvider
      • RSA
      • RSACryptoServiceProvider
      • RSAOAEPKeyExchangeDeformatter
      • RSAOAEPKeyExchangeFormatter
      • RSAParameters
      • RSAPKCS1KeyExchangeDeformatter
      • RSAPKCS1KeyExchangeFormatter
      • RSAPKCS1SignatureDeformatter
      • RSAPKCS1SignatureFormatter
      • SHA1
      • SHA1CryptoServiceProvider
      • SHA1Managed
      • SHA256
      • SHA256Managed
      • SHA384
      • SHA384Managed
      • SHA512
      • SHA512Managed
      • SignatureDescription
      • SymmetricAlgorithm
      • ToBase64Transform
      • TripleDES
      • TripleDESCryptoServiceProvider
    • 25. The System.Security.Cryptography.X509Certificates Namespace
      • X509Certificate
      • X509CertificateCollection
      • X509CertificateCollection.X509CertificateEnumerator
    • 26. The System.Security.Cryptography.Xml Namespace
      • DataObject
      • DSAKeyValue
      • KeyInfo
      • KeyInfoClause
      • KeyInfoName
      • KeyInfoNode
      • KeyInfoRetrievalMethod
      • KeyInfoX509Data
      • Reference
      • RSAKeyValue
      • Signature
      • SignedInfo
      • SignedXml
      • Transform
      • TransformChain
      • XmlDsigBase64Transform
      • XmlDsigC14NTransform
      • XmlDsigC14NWithCommentsTransform
      • XmlDsigEnvelopedSignatureTransform
      • XmlDsigXPathTransform
      • XmlDsigXsltTransform
    • 27. The System.Security.Permissions Namespace
      • CodeAccessSecurityAttribute
      • EnvironmentPermission
      • EnvironmentPermissionAccess
      • EnvironmentPermissionAttribute
      • FileDialogPermission
      • FileDialogPermissionAccess
      • FileDialogPermissionAttribute
      • FileIOPermission
      • FileIOPermissionAccess
      • FileIOPermissionAttribute
      • IsolatedStorageContainment
      • IsolatedStorageFilePermission
      • IsolatedStorageFilePermissionAttribute
      • IsolatedStoragePermission
      • IsolatedStoragePermissionAttribute
      • IUnrestrictedPermission
      • PermissionSetAttribute
      • PermissionState
      • PrincipalPermission
      • PrincipalPermissionAttribute
      • PublisherIdentityPermission
      • PublisherIdentityPermissionAttribute
      • ReflectionPermission
      • ReflectionPermissionAttribute
      • ReflectionPermissionFlag
      • RegistryPermission
      • RegistryPermissionAccess
      • RegistryPermissionAttribute
      • ResourcePermissionBase
      • ResourcePermissionBaseEntry
      • SecurityAction
      • SecurityAttribute
      • SecurityPermission
      • SecurityPermissionAttribute
      • SecurityPermissionFlag
      • SiteIdentityPermission
      • SiteIdentityPermissionAttribute
      • StrongNameIdentityPermission
      • StrongNameIdentityPermissionAttribute
      • StrongNamePublicKeyBlob
      • UIPermission
      • UIPermissionAttribute
      • UIPermissionClipboard
      • UIPermissionWindow
      • UrlIdentityPermission
      • UrlIdentityPermissionAttribute
      • ZoneIdentityPermission
      • ZoneIdentityPermissionAttribute
    • 28. The System.Security.Policy Namespace
      • AllMembershipCondition
      • ApplicationDirectory
      • ApplicationDirectoryMembershipCondition
      • CodeGroup
      • Evidence
      • FileCodeGroup
      • FirstMatchCodeGroup
      • Hash
      • HashMembershipCondition
      • IIdentityPermissionFactory
      • IMembershipCondition
      • NetCodeGroup
      • PermissionRequestEvidence
      • PolicyException
      • PolicyLevel
      • PolicyStatement
      • PolicyStatementAttribute
      • Publisher
      • PublisherMembershipCondition
      • Site
      • SiteMembershipCondition
      • StrongName
      • StrongNameMembershipCondition
      • UnionCodeGroup
      • Url
      • UrlMembershipCondition
      • Zone
      • ZoneMembershipCondition
    • 29. The System.Security.Principal Namespace
      • GenericIdentity
      • GenericPrincipal
      • IIdentity
      • IPrincipal
      • PrincipalPolicy
      • WindowsAccountType
      • WindowsBuiltInRole
      • WindowsIdentity
      • WindowsImpersonationContext
      • WindowsPrincipal
  • Index
  • About the Authors
  • Colophon
  • SPECIAL OFFER: Upgrade this ebook with OReilly

pokaż cały spis treści

ukryj recenzje