using System;
using System.Net;
using System.Security.Cryptography.X509Certificates;

class MainClass {
    public static void Main() {
        WebRequest requestA = WebRequest.Create("http://www.yoursite.com");
        requestA.Credentials = new NetworkCredential("userName", "password");
        requestA.PreAuthenticate = true;
        WebRequest requestB = WebRequest.Create("http://www.yoursite.com");
        requestB.Credentials = CredentialCache.DefaultCredentials;
        requestB.PreAuthenticate = true;

        HttpWebRequest requestC = (HttpWebRequest)WebRequest.Create("http://www.yoursite.com");
        X509Certificate cert1 = X509Certificate.CreateFromCertFile("TestCertificate.cer");
        requestC.ClientCertificates.Add(cert1);
        HttpWebRequest requestD = (HttpWebRequest)WebRequest.Create("http://www.yoursite.com");
        X509Store store = new X509Store();
        X509Certificate2Collection certs = store.Certificates.Find(X509FindType.FindBySubjectName,"Joe", false);

        if (certs.Count == 1) {
            requestD.ClientCertificates.Add(certs[0]);
        } else {
            certs = X509Certificate2UI.SelectFromCollection(
                store.Certificates,
                "Select Certificate",
                "Select the certificate to use for authentication.",
                X509SelectionFlag.SingleSelection);

            if (certs.Count != 0) {
                requestD.ClientCertificates.Add(certs[0]);
            }
        }
    }
}

    

   
 
//---------------------------------------------------------------------
//  This file is part of the Background Motion solution.
// 
//  Copyright (C) Mindscape (TM).  All rights reserved.
//  http://www.mindscape.co.nz
// 
//  THIS CODE AND INFORMATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY
//  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//  PARTICULAR PURPOSE.
//---------------------------------------------------------------------

using System;
using System.Security.Cryptography;
using System.Text;

namespace Mindscape.BackgroundMotion.Core.Utilities
{
  /// <summary>
  /// Helper class which provides functions for assisting with hashing values
  /// </summary>
  public static class Hasher
  {
    /// <summary>
    /// Returns a SHA1 hash of a given plaintext
    /// </summary>
    public static string GetSHA1Hash(string plaintext)
    {
      return BitConverter.ToString(new SHA1CryptoServiceProvider()
        .ComputeHash(Encoding.Default.GetBytes(plaintext)))
        .Replace("-", String.Empty);
    }
  }
}

   
     

   
 
//-----------------------------------------------------------------------
// <copyright file="CryptoUtil.cs" company="Pyramid Consulting">
//     Copyright (c) Pyramid Consulting. All rights reserved.
//  khoa.tran - 15-Dec-2007
// </copyright>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;

namespace Bamboo.Core.Common.Crypto
{
    public class CryptoUtil
    {
        public static byte[] EncryptSHA256(string text)
        {
            SHA256 sha256 = SHA256.Create();
            UTF8Encoding encoding = new UTF8Encoding();
            return sha256.ComputeHash(encoding.GetBytes(text));
        }
    }
}

   
     

   
 
//-----------------------------------------------------------------------
// <copyright file="CryptoUtil.cs" company="Pyramid Consulting">
//     Copyright (c) Pyramid Consulting. All rights reserved.
//  khoa.tran - 15-Dec-2007
// </copyright>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;

namespace Bamboo.Core.Common.Crypto
{
    public class CryptoUtil
    {
        public static byte[] EncryptSHA1(string text)
        {
            SHA1 sha1 = SHA1.Create();
            UTF8Encoding encoding = new UTF8Encoding();
            return sha1.ComputeHash(encoding.GetBytes(text));
        }
   }
}

   
     

   
  
using System;
using System.Text;
using System.Security.Cryptography;

class MainClass {
    public static void Main(string[] args) {
        HashAlgorithm hashAlg = null;
        hashAlg = new SHA1Managed();
        using (hashAlg) {
            byte[] pwordData = Encoding.Default.GetBytes(args[1]);

            byte[] hash = hashAlg.ComputeHash(pwordData);

            Console.WriteLine(BitConverter.ToString(hash));
        }
    }
}

   
     

   
 

using System;
using System.Security.Policy;
using System.Security;
using System.Collections;

class Class1 {
    static void Main() {
        IEnumerator PolicyEnum = SecurityManager.PolicyHierarchy();
        while (PolicyEnum.MoveNext()) {
            PolicyLevel levelPolicy = (PolicyLevel)PolicyEnum.Current;
            Console.WriteLine(levelPolicy.Label);
            IEnumerator PermissionEnum = levelPolicy.NamedPermissionSets.GetEnumerator();
            while (PermissionEnum.MoveNext()) {
                NamedPermissionSet permissionSet = (NamedPermissionSet)PermissionEnum.Current;
                Console.WriteLine("	Permission Set: 
		 Name: {0} 
		 Description {1}", permissionSet.Name, permissionSet.Description);
            }
        }
    }
}

    

   
 

using System.Security;

class MainClass {
    public static void Main() {
        SecurityManager.CheckExecutionRights = true;
        SecurityManager.SavePolicy();
        SecurityManager.CheckExecutionRights = false;

        SecurityManager.SavePolicy();
    }
}