Пример #1
0
        private static void PerformXmlReplace(PwDatabase pd, XmlReplaceOptions opt,
                                              IStatusLogger sl)
        {
            if (opt.SelectNodesXPath.Length == 0)
            {
                return;
            }
            if (opt.Operation == XmlReplaceOp.None)
            {
                return;
            }

            bool bRemove    = (opt.Operation == XmlReplaceOp.RemoveNodes);
            bool bReplace   = (opt.Operation == XmlReplaceOp.ReplaceData);
            bool bMatchCase = ((opt.Flags & XmlReplaceFlags.CaseSensitive) != XmlReplaceFlags.None);
            bool bRegex     = ((opt.Flags & XmlReplaceFlags.Regex) != XmlReplaceFlags.None);

            Regex rxFind = null;

            if (bReplace && bRegex)
            {
                rxFind = new Regex(opt.FindText, (bMatchCase ? RegexOptions.None :
                                                  RegexOptions.IgnoreCase));
            }

            EnsureStandardFieldsExist(pd);

            KdbxFile     kdbxOrg = new KdbxFile(pd);
            MemoryStream msOrg   = new MemoryStream();

            kdbxOrg.Save(msOrg, null, KdbxFormat.PlainXml, sl);
            byte[] pbXml = msOrg.ToArray();
            msOrg.Close();
            string strXml = StrUtil.Utf8.GetString(pbXml);

            XmlDocument xd = new XmlDocument();

            xd.LoadXml(strXml);

            XPathNavigator    xpNavRoot = xd.CreateNavigator();
            XPathNodeIterator xpIt      = xpNavRoot.Select(opt.SelectNodesXPath);

            // XPathNavigators must be cloned to make them independent
            List <XPathNavigator> lNodes = new List <XPathNavigator>();

            while (xpIt.MoveNext())
            {
                lNodes.Add(xpIt.Current.Clone());
            }

            if (lNodes.Count == 0)
            {
                return;
            }

            for (int i = lNodes.Count - 1; i >= 0; --i)
            {
                if ((sl != null) && !sl.ContinueWork())
                {
                    return;
                }

                XPathNavigator xpNav = lNodes[i];

                if (bRemove)
                {
                    xpNav.DeleteSelf();
                }
                else if (bReplace)
                {
                    ApplyReplace(xpNav, opt, rxFind);
                }
                else
                {
                    Debug.Assert(false);
                }                                             // Unknown action
            }

            MemoryStream      msMod = new MemoryStream();
            XmlWriterSettings xws   = new XmlWriterSettings();

            xws.Encoding    = StrUtil.Utf8;
            xws.Indent      = true;
            xws.IndentChars = "\t";
            XmlWriter xw = XmlWriter.Create(msMod, xws);

            xd.Save(xw);

            byte[] pbMod = msMod.ToArray();
            msMod.Close();

            PwDatabase pdMod = new PwDatabase();

            msMod = new MemoryStream(pbMod, false);
            try
            {
                KdbxFile kdbxMod = new KdbxFile(pdMod);
                kdbxMod.Load(msMod, KdbxFormat.PlainXml, sl);
            }
            catch (Exception)
            {
                throw new Exception(KPRes.XmlModInvalid + MessageService.NewParagraph +
                                    KPRes.OpAborted + MessageService.NewParagraph +
                                    KPRes.DbNoModBy.Replace(@"{PARAM}", @"'" + KPRes.XmlReplace + @"'"));
            }
            finally { msMod.Close(); }

            PrepareModDbForMerge(pdMod, pd);

            pd.Modified          = true;
            pd.UINeedsIconUpdate = true;
            pd.MergeIn(pdMod, PwMergeMethod.Synchronize, sl);
        }
Пример #2
0
        public override bool Export(PwExportInfo pwExportInfo, Stream sOutput,
                                    IStatusLogger slLogger)
        {
            PwDatabase pd     = pwExportInfo.ContextDatabase;
            PwGroup    pgRoot = pwExportInfo.DataGroup;

            // Remove everything that requires KDBX 4 or higher;
            // see also KdbxFile.GetMinKdbxVersion

            PwUuid puCipher = pd.DataCipherUuid;

            if (puCipher.Equals(ChaCha20Engine.ChaCha20Uuid))
            {
                pd.DataCipherUuid = StandardAesEngine.AesUuid;
            }

            KdfParameters pKdf   = pd.KdfParameters;
            AesKdf        kdfAes = new AesKdf();

            if (!pKdf.KdfUuid.Equals(kdfAes.Uuid))
            {
                pd.KdfParameters = kdfAes.GetDefaultParameters();
            }

            VariantDictionary vdPublic = pd.PublicCustomData;

            pd.PublicCustomData = new VariantDictionary();

            List <PwGroup>            lCustomGK = new List <PwGroup>();
            List <StringDictionaryEx> lCustomGV = new List <StringDictionaryEx>();
            List <PwEntry>            lCustomEK = new List <PwEntry>();
            List <StringDictionaryEx> lCustomEV = new List <StringDictionaryEx>();

            GroupHandler gh = delegate(PwGroup pg)
            {
                if (pg == null)
                {
                    Debug.Assert(false); return(true);
                }
                if (pg.CustomData.Count > 0)
                {
                    lCustomGK.Add(pg);
                    lCustomGV.Add(pg.CustomData);
                    pg.CustomData = new StringDictionaryEx();
                }
                return(true);
            };
            EntryHandler eh = delegate(PwEntry pe)
            {
                if (pe == null)
                {
                    Debug.Assert(false); return(true);
                }
                if (pe.CustomData.Count > 0)
                {
                    lCustomEK.Add(pe);
                    lCustomEV.Add(pe.CustomData);
                    pe.CustomData = new StringDictionaryEx();
                }
                return(true);
            };

            gh(pgRoot);
            pgRoot.TraverseTree(TraversalMethod.PreOrder, gh, eh);

            try
            {
                KdbxFile kdbx = new KdbxFile(pd);
                kdbx.ForceVersion = KdbxFile.FileVersion32_3;
                kdbx.Save(sOutput, pgRoot, KdbxFormat.Default, slLogger);
            }
            finally
            {
                // Restore

                pd.DataCipherUuid   = puCipher;
                pd.KdfParameters    = pKdf;
                pd.PublicCustomData = vdPublic;

                for (int i = 0; i < lCustomGK.Count; ++i)
                {
                    lCustomGK[i].CustomData = lCustomGV[i];
                }
                for (int i = 0; i < lCustomEK.Count; ++i)
                {
                    lCustomEK[i].CustomData = lCustomEV[i];
                }
            }

            return(true);
        }
Пример #3
0
        /// <summary>
        /// Common program initialization function that can also be
        /// used by applications that use KeePass as a library
        /// (like e.g. KPScript).
        /// </summary>
        public static bool CommonInit()
        {
            m_bDesignMode = false;             // Again, for the ones not calling Main

            m_rndGlobal = CryptoRandom.NewWeakRandom();

            InitEnvSecurity();
            InitAppContext();
            MonoWorkarounds.Initialize();

            // Do not run as AppX, because of compatibility problems
            if (WinUtil.IsAppX)
            {
                return(false);
            }

            try { SelfTest.TestFipsComplianceProblems(); }
            catch (Exception exFips)
            {
                MessageService.ShowWarning(KPRes.SelfTestFailed, exFips);
                return(false);
            }

            // Set global localized strings
            PwDatabase.LocalizedAppName = PwDefs.ShortProductName;
            KdbxFile.DetermineLanguageId();

            m_appConfig = AppConfigSerializer.Load();
            if (m_appConfig.Logging.Enabled)
            {
                AppLogEx.Open(PwDefs.ShortProductName);
            }

            AppPolicy.Current = m_appConfig.Security.Policy.CloneDeep();
            AppPolicy.ApplyToConfig();

            if (m_appConfig.Security.ProtectProcessWithDacl)
            {
                KeePassLib.Native.NativeMethods.ProtectProcessWithDacl();
            }

            m_appConfig.Apply(AceApplyFlags.All);

            m_ecasTriggers = m_appConfig.Application.TriggerSystem;
            m_ecasTriggers.SetToInitialState();

            // InitEnvWorkarounds();
            LoadTranslation();

            CustomResourceManager.Override(typeof(KeePass.Properties.Resources));

#if KP_DEVSNAP
            if (!m_bAsmResReg)
            {
                AppDomain.CurrentDomain.AssemblyResolve += Program.AssemblyResolve;
                m_bAsmResReg = true;
            }
            else
            {
                Debug.Assert(false);
            }
#endif

            return(true);
        }
Пример #4
0
 public void Save(Stream stream)
 {
     var kdbx = new KdbxFile(_db);
     kdbx.Save(stream, null, KdbxFormat.Default, null);
 }
        private async void AddKeeButton_Click(object sender, RoutedEventArgs e)
        {
            List <KeepassClass> PassList = new List <KeepassClass>();
            var           dbpath         = "";
            StorageFolder folder         = Windows.Storage.ApplicationData.Current.LocalFolder;
            StorageFile   file           = await folder.GetFileAsync((string)Windows.Storage.ApplicationData.Current.LocalSettings.Values["KeepassLocalFilePath"]);

            if (file != null)
            {
                dbpath = file.Path;
            }
            var masterpw   = MasterPassword.Password;
            var ioConnInfo = new IOConnectionInfo {
                Path = file.Path
            };
            var compKey = new CompositeKey();

            compKey.AddUserKey(new KcpPassword(MasterPassword.Password));
            var db = new KeePassLib.PwDatabase();

            /*  var kdbx = new KdbxFile(db);
             * using (var fs = await file.OpenReadAsync())
             * {
             *    await Task.Run(() =>
             *    {
             *        kdbx.Load(file.Path, KdbxFormat.Default, null);
             *    });
             *
             *   // return new KdbxDatabase(dbFile, db, dbFile.IdFromPath());
             * }*/
            db.Open(ioConnInfo, compKey, null);
            var pwEntry = new PwEntry(true, true);

            if (!string.IsNullOrEmpty(Title.Text))
            {
                pwEntry.Strings.Set(PwDefs.TitleField, new ProtectedString(true, Title.Text));
            }

            if (!string.IsNullOrEmpty(User.Text))
            {
                pwEntry.Strings.Set(PwDefs.UserNameField, new ProtectedString(true, User.Text));
            }

            if (!string.IsNullOrEmpty(Password.Text))
            {
                pwEntry.Strings.Set(PwDefs.PasswordField, new ProtectedString(true, Password.Text));
            }

            if (!string.IsNullOrEmpty(Notes.Text))
            {
                pwEntry.Strings.Set(PwDefs.NotesField, new ProtectedString(true, Notes.Text));
            }

            if (!string.IsNullOrEmpty(Url.Text))
            {
                pwEntry.Strings.Set(PwDefs.UrlField, new ProtectedString(true, Url.Text));
            }
            // db.RootGroup.AddEntry(pwEntry, true);
            db.RootGroup.Entries.Add(pwEntry);
            db.Modified = true;
            // db.Save();
            var stream = await file.OpenStreamForWriteAsync();

            var kdbx = new KdbxFile(db);

            kdbx.Save(stream, null, KdbxFormat.Default, null);
            db.Close();
            int duration = 3000;

            try {
                TabViewPage.InAppNotificationMain.Show("Saved, please refresh list", duration);
            }
            catch
            {
                IncognitoTabView.InAppNotificationMain.Show("Saved, please refresh list", duration);
            }
        }
Пример #6
0
        /// <summary>
        /// Exports all entries with the given tag to a new database at the given path.
        /// </summary>
        /// <param name="sourceDb">The source database.</param>
        /// <param name="settings">The settings for this job.</param>
        private static void CopyToNewDb(PwDatabase sourceDb, Settings settings)
        {
            // Create a key for the target database
            CompositeKey key = new CompositeKey();

            bool hasPassword = false;
            bool hasKeyFile  = false;

            if (!settings.Password.IsEmpty)
            {
                byte[] passwordByteArray = settings.Password.ReadUtf8();
                key.AddUserKey(new KcpPassword(passwordByteArray));
                MemUtil.ZeroByteArray(passwordByteArray);
                hasPassword = true;
            }

            // Load a keyfile for the target database if requested (and add it to the key)
            if (!string.IsNullOrEmpty(settings.KeyFilePath))
            {
                bool bIsKeyProv = Program.KeyProviderPool.IsKeyProvider(settings.KeyFilePath);

                if (!bIsKeyProv)
                {
                    try
                    {
                        key.AddUserKey(new KcpKeyFile(settings.KeyFilePath, true));
                        hasKeyFile = true;
                    }
                    catch (InvalidDataException exId)
                    {
                        MessageService.ShowWarning(settings.KeyFilePath, exId);
                    }
                    catch (Exception exKf)
                    {
                        MessageService.ShowWarning(settings.KeyFilePath, KPRes.KeyFileError, exKf);
                    }
                }
                else
                {
                    KeyProviderQueryContext ctxKp = new KeyProviderQueryContext(
                        ConnectionInfo, true, false);

                    KeyProvider prov         = Program.KeyProviderPool.Get(settings.KeyFilePath);
                    bool        bPerformHash = !prov.DirectKey;
                    byte[]      pbCustomKey  = prov.GetKey(ctxKp);

                    if ((pbCustomKey != null) && (pbCustomKey.Length > 0))
                    {
                        try
                        {
                            key.AddUserKey(new KcpCustomKey(settings.KeyFilePath, pbCustomKey, bPerformHash));
                            hasKeyFile = true;
                        }
                        catch (Exception exCkp)
                        {
                            MessageService.ShowWarning(exCkp);
                        }

                        MemUtil.ZeroByteArray(pbCustomKey);
                    }
                }
            }

            // Check if at least a password or a keyfile have been added to the key object
            if (!hasPassword && !hasKeyFile)
            {
                // Fail if not
                throw new InvalidOperationException("For the target database at least a password or a keyfile is required.");
            }

            // Create a new database
            PwDatabase targetDatabase = new PwDatabase();

            // Apply the created key to the new database
            targetDatabase.New(new IOConnectionInfo(), key);

            // Copy database settings
            targetDatabase.Color                  = sourceDb.Color;
            targetDatabase.Compression            = sourceDb.Compression;
            targetDatabase.DataCipherUuid         = sourceDb.DataCipherUuid;
            targetDatabase.DefaultUserName        = sourceDb.DefaultUserName;
            targetDatabase.Description            = sourceDb.Description;
            targetDatabase.HistoryMaxItems        = sourceDb.HistoryMaxItems;
            targetDatabase.HistoryMaxSize         = sourceDb.HistoryMaxSize;
            targetDatabase.MaintenanceHistoryDays = sourceDb.MaintenanceHistoryDays;
            targetDatabase.MasterKeyChangeForce   = sourceDb.MasterKeyChangeForce;
            targetDatabase.MasterKeyChangeRec     = sourceDb.MasterKeyChangeRec;
            targetDatabase.Name = sourceDb.Name;
            targetDatabase.RecycleBinEnabled = sourceDb.RecycleBinEnabled;

            if (settings.KeyTransformationRounds == 0)
            {
                // keyTransformationRounds was not set -> use the one from the source database
                settings.KeyTransformationRounds = sourceDb.KdfParameters.GetUInt64(AesKdf.ParamRounds, 0);
            }

            // Set keyTransformationRounds (min PwDefs.DefaultKeyEncryptionRounds)
            targetDatabase.KdfParameters.SetUInt64(AesKdf.ParamRounds, Math.Max(PwDefs.DefaultKeyEncryptionRounds, settings.KeyTransformationRounds));

            // Assign the properties of the source root group to the target root group
            targetDatabase.RootGroup.AssignProperties(sourceDb.RootGroup, false, true);
            HandleCustomIcon(targetDatabase, sourceDb, sourceDb.RootGroup);

            // Overwrite the root group name if requested
            if (!string.IsNullOrEmpty(settings.RootGroupName))
            {
                targetDatabase.RootGroup.Name = settings.RootGroupName;
            }

            // Find all entries matching the tag
            PwObjectList <PwEntry> entries = new PwObjectList <PwEntry>();

            if (!string.IsNullOrEmpty(settings.Tag) && string.IsNullOrEmpty(settings.Group))
            {
                // Tag only export
                sourceDb.RootGroup.FindEntriesByTag(settings.Tag, entries, true);
            }
            else if (string.IsNullOrEmpty(settings.Tag) && !string.IsNullOrEmpty(settings.Group))
            {
                // Tag and group export
                PwGroup groupToExport = sourceDb.RootGroup.GetFlatGroupList().FirstOrDefault(g => g.Name == settings.Group);

                if (groupToExport == null)
                {
                    throw new ArgumentException("No group with the name of the Group-Setting found.");
                }

                entries = groupToExport.GetEntries(true);
            }
            else if (!string.IsNullOrEmpty(settings.Tag) && !string.IsNullOrEmpty(settings.Group))
            {
                // Tag and group export
                PwGroup groupToExport = sourceDb.RootGroup.GetFlatGroupList().FirstOrDefault(g => g.Name == settings.Group);

                if (groupToExport == null)
                {
                    throw new ArgumentException("No group with the name of the Group-Setting found.");
                }

                groupToExport.FindEntriesByTag(settings.Tag, entries, true);
            }
            else
            {
                throw new ArgumentException("At least one of Tag or ExportFolderName must be set.");
            }


            // Copy all entries to the new database
            foreach (PwEntry entry in entries)
            {
                // Get or create the target group in the target database (including hierarchy)
                PwGroup targetGroup = CreateTargetGroupInDatebase(entry, targetDatabase, sourceDb);

                // Clone entry
                PwEntry peNew = new PwEntry(false, false);
                peNew.Uuid = entry.Uuid;
                peNew.AssignProperties(entry, false, true, true);

                // Handle custom icon
                HandleCustomIcon(targetDatabase, sourceDb, entry);

                // Add entry to the target group in the new database
                targetGroup.AddEntry(peNew, true);
            }

            // Create target folder (if not exist)
            string targetFolder = Path.GetDirectoryName(settings.TargetFilePath);

            if (targetFolder == null)
            {
                throw new ArgumentException("Can't get target folder.");
            }
            Directory.CreateDirectory(targetFolder);

            // Save the new database under the target path
            KdbxFile kdbx = new KdbxFile(targetDatabase);

            using (FileStream outputStream = new FileStream(settings.TargetFilePath, FileMode.Create))
            {
                kdbx.Save(outputStream, null, KdbxFormat.Default, new NullStatusLogger());
            }
        }