C# Security.ProtectedBinary类代码示例

        public KcpCustomKey(byte[] pbKeyData)
        {
            Debug.Assert(pbKeyData != null); if(pbKeyData == null) throw new ArgumentNullException("pbKeyData");

            SHA256Managed sha256 = new SHA256Managed();
            byte[] pbRaw = sha256.ComputeHash(pbKeyData);
            m_pbKey = new ProtectedBinary(true, pbRaw);
        }

		public KcpKeyFile(string strKeyFile)
		{
			byte[] pbKey = LoadXmlKeyFile(strKeyFile);
			if(pbKey == null) pbKey = LoadKeyFile(strKeyFile);

			if(pbKey == null) throw new InvalidOperationException();

			m_strPath = strKeyFile;
			m_pbKeyData = new ProtectedBinary(true, pbKey);
		}

		private void SetKey(byte[] pbPasswordUtf8)
		{
			Debug.Assert(pbPasswordUtf8 != null);
			if(pbPasswordUtf8 == null) throw new ArgumentNullException("pbPasswordUtf8");

			SHA256Managed sha256 = new SHA256Managed();
			byte[] pbRaw = sha256.ComputeHash(pbPasswordUtf8);

			m_psPassword = new ProtectedString(true, pbPasswordUtf8);
			m_pbKeyData = new ProtectedBinary(true, pbRaw);
		}

		internal static ProtectedString GetKeyParts(byte[] pbPasswordUtf8, out ProtectedBinary pbKeyData)
		{
			Debug.Assert(pbPasswordUtf8 != null);
			if(pbPasswordUtf8 == null) throw new ArgumentNullException("pbPasswordUtf8");

			SHA256Managed sha256 = new SHA256Managed();
			byte[] pbRaw = sha256.ComputeHash(pbPasswordUtf8);

			var psPassword = new ProtectedString(true, pbPasswordUtf8);
			pbKeyData = new ProtectedBinary(true, pbRaw);
			return psPassword;
		}

		private void SetKey(byte[] pbPasswordUtf8)
		{
			Debug.Assert(pbPasswordUtf8 != null);
			if(pbPasswordUtf8 == null) throw new ArgumentNullException("pbPasswordUtf8");

#if (DEBUG && !KeePassLibSD)
			Debug.Assert(ValidatePassword(pbPasswordUtf8));
#endif

			byte[] pbRaw = CryptoUtil.HashSha256(pbPasswordUtf8);

			m_psPassword = new ProtectedString(true, pbPasswordUtf8);
			m_pbKeyData = new ProtectedBinary(true, pbRaw);
		}

        public KcpCustomKey(string strName, byte[] pbKeyData, bool bPerformHash)
        {
            Debug.Assert(strName != null); if(strName == null) throw new ArgumentNullException("strName");
            Debug.Assert(pbKeyData != null); if(pbKeyData == null) throw new ArgumentNullException("pbKeyData");

            m_strName = strName;

            if(bPerformHash)
            {
                SHA256Managed sha256 = new SHA256Managed();
                byte[] pbRaw = sha256.ComputeHash(pbKeyData);
                m_pbKey = new ProtectedBinary(true, pbRaw);
            }
            else m_pbKey = new ProtectedBinary(true, pbKeyData);
        }

		/// <summary>
		/// Construct a user account key.
		/// </summary>
		public KcpUserAccount()
		{
			// Test if ProtectedData is supported -- throws an exception
			// when running on an old system (Windows 98 / ME).
			byte[] pbDummyData = new byte[128];
			ProtectedData.Protect(pbDummyData, m_pbEntropy,
				DataProtectionScope.CurrentUser);

			byte[] pbKey = LoadUserKey(false);
			if(pbKey == null) pbKey = CreateUserKey();
			if(pbKey == null) throw new SecurityException(KLRes.UserAccountKeyError);

			m_pbKeyData = new ProtectedBinary(true, pbKey);
			Array.Clear(pbKey, 0, pbKey.Length);
		}

        /// <summary>
        /// Construct a user account key.
        /// </summary>
        public KcpUserAccount()
        {
            // Test if ProtectedData is supported -- throws an exception
            // when running on an old system (Windows 98 / ME).
            byte[] pbDummyData = new byte[128];
            ProtectedData.Protect(pbDummyData, m_pbEntropy,
                DataProtectionScope.CurrentUser);

            byte[] pbKey = LoadUserKey(false);
            if(pbKey == null) pbKey = CreateUserKey();
            if(pbKey == null) // Should never happen
            {
                Debug.Assert(false);
                throw new SecurityException(KLRes.UserAccountKeyError);
            }

            m_pbKeyData = new ProtectedBinary(true, pbKey);
            MemUtil.ZeroByteArray(pbKey);
        }

		private void Init(bool bEnableProtection, byte[] pbUtf8)
		{
			if(pbUtf8 == null) throw new ArgumentNullException("pbUtf8");

			m_bIsProtected = bEnableProtection;

			if(bEnableProtection)
				m_pbUtf8 = new ProtectedBinary(true, pbUtf8);
			else
				m_strPlainText = StrUtil.Utf8.GetString(pbUtf8, 0, pbUtf8.Length);
		}

        public static void UpdateKeePassEntry(PwEntry entry,
            string username = "",
            string title = "",
            string url = "",
            string notes = "",
            string password = "",
            string[] attachments = null,
            string[] tags = null)
        {
            UpdateValue(entry, "UserName", username);
            UpdateValue(entry, "Title", title);
            UpdateValue(entry, "URL", url);
            UpdateValue(entry, "Notes", notes);
            UpdateValue(entry, "Password", password);

            if(tags != null)
            {
                var tagsCopy = entry.Tags.ToArray();
                foreach(var tag in tagsCopy)
                    entry.RemoveTag(tag);

                foreach (var tag in tags)
                    entry.AddTag(tag);
            }

            if (attachments != null)
            {
                var fileNames = attachments.Select(o => Path.GetFileName(o)).ToList();
                var binaries = entry.Binaries.CloneDeep();
                var filesToAdd = new List<string>();

                foreach(var binary in binaries)
                {
                    entry.Binaries.Remove(binary.Key);
                }

                foreach(var attachment in attachments)
                {
                    var fileName = Path.GetFileName(attachment);

                    var bytes = File.ReadAllBytes(attachment);
                    if(bytes != null)
                    {
                        var protectedBytes = new ProtectedBinary(true, bytes);
                        entry.Binaries.Set(fileName, protectedBytes);
                    }
                }
            }
        }

        private void Construct(IOConnectionInfo iocFile)
        {
            byte[] pbKey = LoadXmlKeyFile(iocFile);
            if(pbKey == null) pbKey = LoadKeyFile(iocFile);

            if(pbKey == null) throw new InvalidOperationException();

            m_strPath = iocFile.Path;
            m_pbKeyData = new ProtectedBinary(true, pbKey);
        }

        private void OnCtxBinNew(object sender, EventArgs e)
        {
            if(m_pwEditMode == PwEditMode.ViewReadOnlyEntry) return;

            string strName;
            for(int i = 0; ; ++i)
            {
                strName = KPRes.New;
                if(i >= 1) strName += " (" + i.ToString() + ")";
                strName += ".rtf";

                if(m_vBinaries.Get(strName) == null) break;
            }

            ProtectedBinary pb = new ProtectedBinary();
            m_vBinaries.Set(strName, pb);
            UpdateEntryBinaries(false, true, strName);
            ResizeColumnHeaders();

            ListViewItem lviNew = m_lvBinaries.FindItemWithText(strName,
                false, 0, false);
            if(lviNew != null) lviNew.BeginEdit();
        }

        private string BinPoolFind(ProtectedBinary pb)
        {
            if(pb == null) { Debug.Assert(false); return null; }

            foreach(KeyValuePair<string, ProtectedBinary> kvp in m_dictBinPool)
            {
                if(pb.Equals(kvp.Value)) return kvp.Key;
            }

            return null;
        }

		/// <summary>
		/// Construct a new protected binary data object. Copy the data from
		/// an existing object.
		/// </summary>
		/// <param name="pbTemplate">Existing <c>ProtectedBinary</c> object,
		/// which is used to initialize the new object. This parameter must
		/// not be <c>null</c>.</param>
		/// <exception cref="System.ArgumentNullException">Thrown if the input
		/// parameter is <c>null</c>.</exception>
		public ProtectedBinary(ProtectedBinary pbTemplate)
		{
			Debug.Assert(pbTemplate != null); if(pbTemplate == null) throw new ArgumentNullException("pbTemplate");

			m_bDoProtect = pbTemplate.m_bDoProtect;

			byte[] pbBuf = pbTemplate.ReadData();
			SetData(pbBuf);
			MemUtil.ZeroByteArray(pbBuf);
		}

        private void BinPoolAdd(ProtectedBinary pb)
        {
            if(pb == null) { Debug.Assert(false); return; }

            if(BinPoolFind(pb) != null) return; // Exists already

            m_dictBinPool.Add(m_dictBinPool.Count.ToString(), pb);
        }