internal IKeyImpl ReleaseKeyImpl() { IKeyImpl result = keyImpl_; keyImpl_ = null; return(result); }
public ucDataConnectionEditor(IBaseNode node) { InitializeComponent(); baseNode = node; lblTitle.Text = node.Name; string UserAppFolder = ConfigurationRepository.IConfiguration.GetConfigurationValue("UserAppDataPath", ""); rootPath = string.Format("{0}{1}-{2}-config.xml", UserAppFolder, node.Parent.Name.ToLower(), node.Name.ToLower()); conf.AddConfigurationSource( new IConfigurationSourceImpl("UserAppDataPath", Constants.ConfigurationSource, rootPath)); string keyId = string.Format("{0}-{1}", node.Parent.Name.ToLower(), node.Name.ToLower()); IKey key = new IKeyImpl(keyId); key.keyBytes = KeyUtils.GetBytes(node.Reference.Replace("-", "")); conf.IKms.AddKey(key); IConfigurationItem item = new IConfigurationItemImpl("secret", "", Constants.ConfigurationSource); item.StorageKey = keyId; conf.AddConfigurationItem(item); string plain = item.GetValue(""); log.Debug(plain); }
private bool TryOpenOrCreateDiffKey(KeyIdentity existingBase, KeyIdentity identity, KeySecurity samDesired, out IKeyImpl openedImpl) { if (TryOpen(existingBase, KeyDisposition.DIFF_HIVE, identity, samDesired, out openedImpl)) { return(true); } // If some modification operation is requested and offreg key // does not exist, but it is in one of readonly hives - creating it if (samDesired.IsOnlyForRead() || !KeyExistsInROHives(identity)) { return(false); } try { openedImpl = Create(identity, null, (int)Win32Api.RegOption.REG_OPTION_NON_VOLATILE, IntPtr.Zero, IntPtr.Zero); return(true); } catch (FileNotFoundException) { return(false); } }
// existingBase is passed for performance optimization // TODO: encapsulate existingBase in a class and extract methods // with it a first argument there private bool TryOpenImpl(KeyIdentity existingBase, KeyDisposition disposition, KeyIdentity identity, KeySecurity samDesired, out IKeyImpl openedImpl) { openedImpl = null; if (disposition != KeyDisposition.DIFF_HIVE) { if (diffHive_.IsMarkedAsDeleted(existingBase, identity)) { return(false); } } IKeyImplOpenFactory factory = null; switch (disposition) { case KeyDisposition.WINDOWS_REG: factory = windowsKeyFactory_; break; case KeyDisposition.BASE_HIVE: factory = baseHive_; break; case KeyDisposition.DIFF_HIVE: factory = diffHive_; break; } if (factory == null) { // In case if specified hive is not used (currently used // only for null baseHive_) return(false); } return(factory.TryOpen(identity, samDesired, out openedImpl)); }
protected void InitializeKMS() { log.Debug("Creating system key"); NetworkInterface nic = null; foreach (NetworkInterface adapter in NetworkInterface.GetAllNetworkInterfaces()) { if (adapter.Name == "LAN-verbinding") { nic = adapter; break; } } if (nic != null) { IKey key = new IKeyImpl("system"); if (key.KeyValueFromGuid(nic.Id)) { Kms.AddKey(key); } log.Debug("System key created"); return; } log.Debug("System key not created"); }
public bool TryOpen(KeyIdentity identity, KeySecurity samDesired, out IKeyImpl openedImpl) { WindowsKey windowsKey; bool result = WindowsKey.TryOpen(identity, samDesired, out windowsKey); openedImpl = windowsKey; return(result); }
public bool TryOpen(KeyIdentity identity, KeySecurity samDesired, out IKeyImpl openedImpl) { OffRegKey offregKey; bool result = OffRegKey.TryOpen(this, hive_, identity, out offregKey); openedImpl = offregKey; return(result); }
internal VirtualKey(VirtualKeyFactory opener, KeyIdentity identity, IKeyImpl baseKeyImpl, DataAlterer alterer) { opener_ = opener; identity_ = identity; baseImpl_ = baseKeyImpl; alterer_ = alterer; ReinitializeCache(); }
// returns false if the key does not exist in the given disposition, // on other errors throws exception. private bool TryOpen(KeyIdentity existingBase, KeyDisposition disposition, KeyIdentity identity, KeySecurity samDesired, out IKeyImpl openedImpl) { if (!TryOpenImpl(existingBase, disposition, identity, samDesired, out openedImpl)) { return(false); } baseKeyManager_.BaseKeyCopied(identity.BaseKey); openedImpl = new KeyImplDecoratorHookingClose(openedImpl, () => baseKeyManager_.BaseKeyClosed(identity.BaseKey)); return(true); }
protected /*virtual*/ override void DisposeUnmanaged() { if (keyImpl_ != null) { // Ignoring errors such as closing a predefined key try { keyImpl_.Close(); } catch { } keyImpl_ = null; } }
private bool TryGetSubKey(KeyDisposition disposition, string lpSubKey, KeySecurity samDesired, Win32Api.RegWow64Options wowOptions, out KeyImplHolder subKeyHolder) { KeyIdentity subKeyIdentity = new KeyIdentity(identity_, wowOptions, lpSubKey); IKeyImpl keyImpl = cachedKeyImpls_.TryGet(subKeyIdentity, disposition, samDesired); if (keyImpl != null) { subKeyHolder = new NotOwningKeyImplHolder(keyImpl); return(true); } KeyImplHolder newOne; if (!opener_.TryOpenHolder(identity_, disposition, subKeyIdentity, samDesired, out newOne)) { subKeyHolder = null; return(false); } subKeyHolder = cachedKeyImpls_.Add(subKeyIdentity, disposition, newOne); return(true); }
internal VirtualKey CreateKey(KeyIdentity identity, string lpClass, Win32Api.RegOption dwOptions, IntPtr lpSecurityAttributes) { // Security attributes and security descriptor are not the same IntPtr securityDescriptor = IntPtr.Zero; if (lpSecurityAttributes != IntPtr.Zero) { Win32Api.SECURITY_ATTRIBUTES securityAttributes = (Win32Api.SECURITY_ATTRIBUTES)Marshal.PtrToStructure( lpSecurityAttributes, typeof(Win32Api.SECURITY_ATTRIBUTES)); if (securityAttributes.nLength >= Marshal.SizeOf(typeof(UInt32)) + Marshal.SizeOf(typeof(IntPtr))) { securityDescriptor = securityAttributes.lpSecurityDescriptor; } } IKeyImpl registryKey = Create(identity, lpClass, dwOptions, securityDescriptor, IntPtr.Zero); return(new VirtualKey(this, identity, registryKey, alterer_)); }
internal bool TryAlterData(KeyIdentity key, string valueName, IKeyImpl keyImpl, IntPtr pdwType, Data dst, DataTransformer.Operation operation) { // TODO: this is a specific check that // rewrite is done only for values in sandboxie reghive which is BASE_HIVE // and if values are copied, DIFF_HIVE is also supported // It should be put outside this generalized class if (keyImpl.GetDisposition() == KeyDisposition.WINDOWS_REG) { return(Win32Exception.CheckIfFoundAndNoError(operation(pdwType, dst))); } return(DataTransformer.TryAlterData(pdwType, dst, operation, (result, type) => { DebugLogger.WriteLine(@"AlterData {0} {1}\{2} ({3}) Result: {4}", keyImpl.GetDisposition(), key.ToString(), valueName, type, (int)result); return result == Win32Api.Error.ERROR_SUCCESS && DataTransformer.IsStringType(type); }, (type, pSrcData, cbSrcData) => DataTransformer.TransformStringValue( type, pSrcData, cbSrcData, dst, str => CallStrAlterers(key, valueName, str), HookBarrier.IsLastInjectedFuncAnsi ? StringFormat.Ansi : StringFormat.Unicode))); }
// private string debugCreationCallStack_; internal KeyImplHolder(IKeyImpl keyImpl) { keyImpl_ = keyImpl; // debugCreationCallStack_ = Environment.StackTrace; }
private DoesntExistOrMarkedAsDeletedState DoesntExistOrMarkedAsDeleted(KeyIdentity existingBase, KeyIdentity identity, IntPtr allocatedpData, IntPtr allocatedpcbData) { string[] subkeys = identity.SplitPath(); int existingLevels, nonRemovableLevels; CalcNonRemovableLevels(existingBase, identity, out existingLevels, out nonRemovableLevels); if (subkeys.Length <= nonRemovableLevels) { return(DoesntExistOrMarkedAsDeletedState.Exists); } for (int level = existingLevels; level < subkeys.Length; level++) { KeyIdentity curLevelIdentity = KeyIdentity.Build(identity.BaseKey, subkeys, level); KeyImplHolder holder; lock (this) { IKeyImpl keyImpl = null; if (level <= nonRemovableLevels) { keyImpl = cacheForDeletedMarks_.TryGet(curLevelIdentity, KeyDisposition.DIFF_HIVE, cacheSecurity_); } if (keyImpl != null) { holder = new NotOwningKeyImplHolder(keyImpl); } else { OffregLib.OffregKey key; OffregLib.Win32Result result; if (!hive_.Root.TryOpenSubKey(OffRegKey.GetMainOffRegPath(curLevelIdentity), out key, out result)) { return(DoesntExistOrMarkedAsDeletedState.DoesntExist); } holder = new KeyImplHolder(new OffRegKey(this, key, curLevelIdentity)); if (level <= nonRemovableLevels) { // Adding to cache only the lowest, non removable level holder = cacheForDeletedMarks_.Add( curLevelIdentity, KeyDisposition.DIFF_HIVE, holder); } } } using (holder) { Marshal.WriteInt32(allocatedpcbData, Marshal.SizeOf(typeof(int))); if (holder.GetKeyImpl().TryQueryValue( DELETED_PREFIX + subkeys[level], IntPtr.Zero, IntPtr.Zero, allocatedpData, allocatedpcbData)) { if (Marshal.ReadInt32(allocatedpcbData) == Marshal.SizeOf(typeof(int)) && Marshal.ReadInt32(allocatedpData) != 0) { // There is a special value marking key as deleted return(DoesntExistOrMarkedAsDeletedState.MarkedAsDeleted); } } } } return(DoesntExistOrMarkedAsDeletedState.Exists); }
internal KeyImplDecoratorHookingClose(IKeyImpl decorated, Callback callback) { decorated_ = decorated; callback_ = callback; }
private bool TryAlterData(string subKey, string value, IKeyImpl keyImpl, IntPtr pdwType, Data dst, DataTransformer.Operation operation) { return(alterer_.TryAlterData(new KeyIdentity(identity_, Win32Api.RegWow64Options.None, subKey), value, keyImpl, pdwType, dst, operation)); }
internal NotOwningKeyImplHolder(IKeyImpl keyImpl) : base(keyImpl) { }