C# 安全性

一、标识和Principal

 static void Main(string[] args)
         {
             AppDomain.CurrentDomain.SetPrincipalPolicy(System.Security.Principal.PrincipalPolicy.WindowsPrincipal);
             var principal = WindowsPrincipal.Current as WindowsPrincipal;
             var identity = principal.Identity as WindowsIdentity;

             Console.WriteLine("IdentityType: {0}", identity.ToString());
             Console.WriteLine("Name: {0}", identity.Name);
             Console.WriteLine("‘Users’?: {0}", principal.IsInRole(WindowsBuiltInRole.User));
             Console.WriteLine("‘Administrators’? {0}", principal.IsInRole(WindowsBuiltInRole.Administrator));
             Console.WriteLine("Authenticated: {0}", identity.IsAuthenticated);
             Console.WriteLine("AuthType: {0}", identity.AuthenticationType);
             Console.WriteLine("Anonymous? {0}", identity.IsAnonymous);
             Console.WriteLine("Token: {0}", identity.Token);

             Console.WriteLine();
             Console.WriteLine("Claims");
             foreach (var claim in principal.Claims)
             {
                 Console.WriteLine("Subject: {0}", claim.Subject);
                 Console.WriteLine("Issuer: {0}", claim.Issuer);
                 Console.WriteLine("Type: {0}", claim.Type);
                 Console.WriteLine("Value type: {0}", claim.ValueType);
                 Console.WriteLine("Value: {0}", claim.Value);
                 foreach (var prop in claim.Properties)
                 {
                     Console.WriteLine("\tProperty: {0} {1}", prop.Key, prop.Value);
                 }
                 Console.WriteLine();

             }

             Console.Read();
         }

二、声明基于角色的安全性

  static void Main(string[] args)
         {
             AppDomain.CurrentDomain.SetPrincipalPolicy(System.Security.Principal.PrincipalPolicy.WindowsPrincipal);
             try
             {
                 ShowMessage();

             }
             catch (Exception ex)
             {

             }

         }
         [PrincipalPermission(SecurityAction.Demand,Role="administrator")]
         static void ShowMessage()
         {
             Console.WriteLine("The current principal is logged in locally");

         }

三、ECDSA算法签名

   class Program
     {
         internal static CngKey aliceKeySignature;
         internal static byte[] alicePubKeyBlob;

         static void Main(string[] args)
         {
             CreateKeys();
             byte[] aliceData = Encoding.UTF8.GetBytes("Alice");
             byte[] aliceSignature = CreateSignature(aliceData, aliceKeySignature);
             Console.WriteLine("Alice created signature: {0}",
              Convert.ToBase64String(aliceSignature));

             if (VerifySignature(aliceData, aliceSignature, alicePubKeyBlob))
             {
                 Console.WriteLine("Alice signature verified successfully");
             }
         }

         static void CreateKeys()
         {
             aliceKeySignature = CngKey.Create(CngAlgorithm.ECDsaP256);
             alicePubKeyBlob = aliceKeySignature.Export(CngKeyBlobFormat.GenericPublicBlob);
         }

         static byte[] CreateSignature(byte[] data,CngKey key)
         {
             byte[] signature;
             using (var signingAlg=new ECDsaCng(key))
             {
                 signature = signingAlg.SignData(data);
                 signingAlg.Clear();
             }
             return signature;
         }
         static bool VerifySignature(byte[] data, byte[] signature, byte[] pubKey)
         {
             bool retValue = false;
             using (CngKey key = CngKey.Import(pubKey, CngKeyBlobFormat.GenericPublicBlob))
             using (var signingAlg = new ECDsaCng(key))
             {
                 retValue = signingAlg.VerifyData(data, signature);
                 signingAlg.Clear();
             }
             return retValue;
         }
     }

四、交换密钥和安全传输

  class Program
     {
         static CngKey aliceKey;
         static CngKey bobKey;
         static byte[] alicePubKeyBlob;
         static byte[] bobPubKeyBlob;

         static void Main()
         {
             Run();
             Console.ReadLine();
         }

         private async static void Run()
         {
             try
             {
                 CreateKeys();
                 byte[] encrytpedData = await AliceSendsData("secret message");
                 await BobReceivesData(encrytpedData);
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.Message);
             }
         }

         private static void CreateKeys()
         {
             aliceKey = CngKey.Create(CngAlgorithm.ECDiffieHellmanP256);
             bobKey = CngKey.Create(CngAlgorithm.ECDiffieHellmanP256);
             alicePubKeyBlob = aliceKey.Export(CngKeyBlobFormat.EccPublicBlob);
             bobPubKeyBlob = bobKey.Export(CngKeyBlobFormat.EccPublicBlob);
         }

         private async static Task<byte[]> AliceSendsData(string message)
         {
             Console.WriteLine("Alice sends message: {0}", message);
             byte[] rawData = Encoding.UTF8.GetBytes(message);
             byte[] encryptedData = null;

             using (var aliceAlgorithm = new ECDiffieHellmanCng(aliceKey))
             using (CngKey bobPubKey = CngKey.Import(bobPubKeyBlob,
                   CngKeyBlobFormat.EccPublicBlob))
             {
                 byte[] symmKey = aliceAlgorithm.DeriveKeyMaterial(bobPubKey);
                 Console.WriteLine("Alice creates this symmetric key with " +
                       "Bobs public key information: {0}",
                       Convert.ToBase64String(symmKey));

                 using (var aes = new AesCryptoServiceProvider())
                 {
                     aes.Key = symmKey;
                     aes.GenerateIV();
                     using (ICryptoTransform encryptor = aes.CreateEncryptor())
                     using (MemoryStream ms = new MemoryStream())
                     {
                         // create CryptoStream and encrypt data to send
                         var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write);

                         // write initialization vector not encrypted
                         await ms.WriteAsync(aes.IV, , aes.IV.Length);
                         await cs.WriteAsync(rawData, , rawData.Length);
                         cs.Close();
                         encryptedData = ms.ToArray();
                     }
                     aes.Clear();
                 }
             }
             Console.WriteLine("Alice: message is encrypted: {0}", Convert.ToBase64String(encryptedData)); ;
             Console.WriteLine();
             return encryptedData;
         }

         private async static Task BobReceivesData(byte[] encryptedData)
         {
             Console.WriteLine("Bob receives encrypted data");
             byte[] rawData = null;

             var aes = new AesCryptoServiceProvider();

             int nBytes = aes.BlockSize >> ;
             byte[] iv = new byte[nBytes];
             for (int i = ; i < iv.Length; i++)
                 iv[i] = encryptedData[i];

             using (var bobAlgorithm = new ECDiffieHellmanCng(bobKey))
             using (CngKey alicePubKey = CngKey.Import(alicePubKeyBlob,
                   CngKeyBlobFormat.EccPublicBlob))
             {
                 byte[] symmKey = bobAlgorithm.DeriveKeyMaterial(alicePubKey);
                 Console.WriteLine("Bob creates this symmetric key with " +
                       "Alices public key information: {0}",
                       Convert.ToBase64String(symmKey));

                 aes.Key = symmKey;
                 aes.IV = iv;

                 using (ICryptoTransform decryptor = aes.CreateDecryptor())
                 using (MemoryStream ms = new MemoryStream())
                 {
                     var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write);
                     await cs.WriteAsync(encryptedData, nBytes, encryptedData.Length - nBytes);
                     cs.Close();

                     rawData = ms.ToArray();

                     Console.WriteLine("Bob decrypts message to: {0}",
                           Encoding.UTF8.GetString(rawData));
                 }
                 aes.Clear();
             }
         }
     }