public static bool Export(PwExportInfo pwExportInfo, IStatusLogger slLogger) { if(pwExportInfo == null) throw new ArgumentNullException("pwExportInfo"); if(pwExportInfo.DataGroup == null) throw new ArgumentException(); if(!AppPolicy.Try(AppPolicyId.Export)) return false; ExchangeDataForm dlg = new ExchangeDataForm(); dlg.InitEx(true, pwExportInfo.ContextDatabase, pwExportInfo.DataGroup); if(dlg.ShowDialog() == DialogResult.OK) { FileFormatProvider ffp = dlg.ResultFormat; if(ffp == null) { Debug.Assert(false); return false; } if(ffp.RequiresFile) { if(dlg.ResultFiles.Length != 1) { Debug.Assert(false); return false; } if(dlg.ResultFiles[0] == null) { Debug.Assert(false); return false; } if(dlg.ResultFiles[0].Length == 0) { Debug.Assert(false); return false; } } Application.DoEvents(); // Redraw parent window IOConnectionInfo iocOutput = (ffp.RequiresFile ? IOConnectionInfo.FromPath( dlg.ResultFiles[0]) : null); try { return Export(pwExportInfo, dlg.ResultFormat, iocOutput, slLogger); } catch(Exception ex) { MessageService.ShowWarning(ex); } } return false; }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, StrUtil.Utf8); string strDoc = sr.ReadToEnd(); sr.Close(); XmlDocument doc = new XmlDocument(); doc.LoadXml(strDoc); XmlElement xmlRoot = doc.DocumentElement; Debug.Assert(xmlRoot.Name == ElemRoot); PwGroup pgRoot = pwStorage.RootGroup; foreach(XmlNode xmlChild in xmlRoot.ChildNodes) { if(xmlChild.Name == ElemGroup) ImportGroup(xmlChild, pgRoot, pwStorage, false); else if(xmlChild.Name == ElemRecycleBin) ImportGroup(xmlChild, pgRoot, pwStorage, true); else if(xmlChild.Name == ElemEntry) ImportEntry(xmlChild, pgRoot, pwStorage); else { Debug.Assert(false); } } }
public static void Export(PwExportInfo pwExportInfo, IStatusLogger slLogger) { if(pwExportInfo == null) throw new ArgumentNullException("pwExportInfo"); if(pwExportInfo.DataGroup == null) throw new ArgumentException(); if(!AppPolicy.Try(AppPolicyId.Export)) return; ExchangeDataForm dlg = new ExchangeDataForm(); dlg.InitEx(true, pwExportInfo.ContextDatabase, pwExportInfo.DataGroup); if(dlg.ShowDialog() == DialogResult.OK) { if(dlg.ResultFormat == null) { Debug.Assert(false); return; } if(dlg.ResultFiles.Length != 1) { Debug.Assert(false); return; } if(dlg.ResultFiles[0] == null) { Debug.Assert(false); return; } if(dlg.ResultFiles[0].Length == 0) { Debug.Assert(false); return; } Application.DoEvents(); // Redraw parent window try { PerformExport(pwExportInfo, dlg.ResultFormat, dlg.ResultFiles[0], slLogger); } catch(Exception ex) { MessageService.ShowWarning(ex); } } }
public override bool Export(PwExportInfo pwExportInfo, Stream sOutput, IStatusLogger slLogger) { PwGroup pg = pwExportInfo.DataGroup; if(pg == null) { Debug.Assert(false); return true; } string strBaseName = FilterFileName(string.IsNullOrEmpty( Program.Config.Defaults.WinFavsBaseFolderName) ? PwDefs.ShortProductName : Program.Config.Defaults.WinFavsBaseFolderName); string strRootName = strBaseName + " - " + FilterFileName(pg.Name); if(pwExportInfo.ContextDatabase != null) { if(pg == pwExportInfo.ContextDatabase.RootGroup) strRootName = strBaseName; } string strFavsRoot = Environment.GetFolderPath( Environment.SpecialFolder.Favorites); if(string.IsNullOrEmpty(strFavsRoot)) return false; string strFavsSub = UrlUtil.EnsureTerminatingSeparator(strFavsRoot, false) + strRootName; if(Directory.Exists(strFavsSub)) { Directory.Delete(strFavsSub, true); WaitForDirCommit(strFavsSub, false); } ExportGroup(pwExportInfo.DataGroup, strFavsSub); return true; }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(sInput); XmlNode xmlRoot = xmlDoc.DocumentElement; Debug.Assert(xmlRoot.Name == ElemRoot); Stack<PwGroup> vGroups = new Stack<PwGroup>(); vGroups.Push(pwStorage.RootGroup); int nNodeCount = xmlRoot.ChildNodes.Count; for(int i = 0; i < nNodeCount; ++i) { XmlNode xmlChild = xmlRoot.ChildNodes[i]; if(xmlChild.Name == ElemGroup) ReadGroup(xmlChild, vGroups, pwStorage); else { Debug.Assert(false); } if(slLogger != null) slLogger.SetProgress((uint)(((i + 1) * 100) / nNodeCount)); } }
public override bool Export(PwExportInfo pwExportInfo, Stream sOutput, IStatusLogger slLogger) { Kdb4File kdb4 = new Kdb4File(pwExportInfo.ContextDatabase); kdb4.Save(sOutput, pwExportInfo.DataGroup, Kdb4Format.Default, slLogger); return true; }
/// <summary> /// Default constructor. /// </summary> /// <param name="pwDataStore">The <c>PwDatabase</c> instance that the class /// will load file data into or use to create a KDB file. Must not be <c>null</c>.</param> /// <exception cref="System.ArgumentNullException">Thrown if the database /// reference is <c>null</c>.</exception> public KdbFile(PwDatabase pwDataStore, IStatusLogger slLogger) { Debug.Assert(pwDataStore != null); if(pwDataStore == null) throw new ArgumentNullException("pwDataStore"); m_pwDatabase = pwDataStore; m_slLogger = slLogger; }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { XmlSerializer xs = new XmlSerializer(typeof(HspFolder)); HspFolder hspRoot = (HspFolder)xs.Deserialize(sInput); AddFolder(pwStorage.RootGroup, hspRoot, false); }
// public void Save(string strFile, PwGroup pgDataSource, KdbxFormat format, // IStatusLogger slLogger) // { // bool bMadeUnhidden = UrlUtil.UnhideFile(strFile); // // IOConnectionInfo ioc = IOConnectionInfo.FromPath(strFile); // this.Save(IOConnection.OpenWrite(ioc), pgDataSource, format, slLogger); // // if(bMadeUnhidden) UrlUtil.HideFile(strFile, true); // Hide again // } /// <summary> /// Save the contents of the current <c>PwDatabase</c> to a KDBX file. /// </summary> /// <param name="sSaveTo">Stream to write the KDBX file into.</param> /// <param name="pgDataSource">Group containing all groups and /// entries to write. If <c>null</c>, the complete database will /// be written.</param> /// <param name="format">Format of the file to create.</param> /// <param name="slLogger">Logger that recieves status information.</param> public void Save(Stream sSaveTo, PwGroup pgDataSource, KdbxFormat format, IStatusLogger slLogger) { Debug.Assert(sSaveTo != null); if(sSaveTo == null) throw new ArgumentNullException("sSaveTo"); m_format = format; m_slLogger = slLogger; HashingStreamEx hashedStream = new HashingStreamEx(sSaveTo, true, null); UTF8Encoding encNoBom = StrUtil.Utf8; CryptoRandom cr = CryptoRandom.Instance; try { m_pbMasterSeed = cr.GetRandomBytes(32); m_pbTransformSeed = cr.GetRandomBytes(32); m_pbEncryptionIV = cr.GetRandomBytes(16); m_pbProtectedStreamKey = cr.GetRandomBytes(32); m_craInnerRandomStream = CrsAlgorithm.Salsa20; m_randomStream = new CryptoRandomStream(m_craInnerRandomStream, m_pbProtectedStreamKey); m_pbStreamStartBytes = cr.GetRandomBytes(32); Stream writerStream; if(m_format == KdbxFormat.Default) { WriteHeader(hashedStream); // Also flushes the stream Stream sEncrypted = AttachStreamEncryptor(hashedStream); if((sEncrypted == null) || (sEncrypted == hashedStream)) throw new SecurityException(KLRes.CryptoStreamFailed); sEncrypted.Write(m_pbStreamStartBytes, 0, m_pbStreamStartBytes.Length); Stream sHashed = new HashedBlockStream(sEncrypted, true); if(m_pwDatabase.Compression == PwCompressionAlgorithm.GZip) writerStream = new GZipStream(sHashed, CompressionMode.Compress); else writerStream = sHashed; } else if(m_format == KdbxFormat.PlainXml) writerStream = hashedStream; else { Debug.Assert(false); throw new FormatException("KdbFormat"); } m_xmlWriter = new XmlTextWriter(writerStream, encNoBom); WriteDocument(pgDataSource); m_xmlWriter.Flush(); m_xmlWriter.Close(); writerStream.Close(); } finally { CommonCleanUpWrite(sSaveTo, hashedStream); } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { XPathDocument xpDoc = new XPathDocument(sInput); XPathNavigator xpNav = xpDoc.CreateNavigator(); ImportLogins(xpNav, pwStorage); ImportMemos(xpNav, pwStorage); }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.Default); string strDoc = sr.ReadToEnd(); sr.Close(); ImportFileString(strDoc, pwStorage); }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.Default); string strDoc = sr.ReadToEnd(); sr.Close(); int nIndex = strDoc.IndexOf('<'); while(nIndex >= 0) { int nAttrib = strDoc.LastIndexOf("=\"", nIndex); int nElem = strDoc.LastIndexOf('>', nIndex); if(nAttrib > nElem) { strDoc = strDoc.Remove(nIndex, 1); strDoc = strDoc.Insert(nIndex, @"<"); } nIndex = strDoc.IndexOf('<', nIndex + 1); } nIndex = strDoc.IndexOf('>'); while(nIndex >= 0) { if(nIndex <= 3) throw new FormatException("Invalid header!"); char chPrev = strDoc[nIndex - 1]; string strPrev4 = strDoc.Substring(nIndex - 3, 4); if((chPrev != '/') && (chPrev != '\"') && (strPrev4 != @"xml>") && (strPrev4 != @"ies>")) { strDoc = strDoc.Remove(nIndex, 1); strDoc = strDoc.Insert(nIndex, @">"); } nIndex = strDoc.IndexOf('>', nIndex + 1); } MemoryStream msXml = new MemoryStream(Encoding.UTF8.GetBytes(strDoc), false); XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(msXml); msXml.Close(); XmlNode xmlRoot = xmlDoc.DocumentElement; if(xmlRoot.Name != ElemRoot) throw new FormatException("Invalid root element!"); foreach(XmlNode xmlChild in xmlRoot.ChildNodes) { if(xmlChild.Name == ElemEntries) ImportEntries(xmlChild, pwStorage); else { Debug.Assert(false); } } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { KdbxFile kdbx = new KdbxFile(pwStorage); // CappedByteStream s = new CappedByteStream(sInput, 64); kdbx.RepairMode = true; try { kdbx.Load(sInput, KdbxFormat.Default, slLogger); } catch(Exception) { } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { BinaryReader br = new BinaryReader(sInput); byte[] pbData = br.ReadBytes((int)sInput.Length); br.Close(); ImportCsvForm csv = new ImportCsvForm(); csv.InitEx(pwStorage, pbData); csv.ShowDialog(); }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.Default); string strData = sr.ReadToEnd(); sr.Close(); strData = strData.Replace("\r", string.Empty); string[] vLines = strData.Split(new char[] { '\n' }); PwGroup pg = pwStorage.RootGroup; Dictionary<string, string> dItems = new Dictionary<string, string>(); bool bInNotes = false; foreach(string strLine in vLines) { if(strLine.StartsWith(StrGroupStart) && strLine.EndsWith(StrGroupEnd)) { AddEntry(pg, dItems, ref bInNotes); dItems.Clear(); pg = new PwGroup(true, true); pg.Name = strLine.Substring(StrGroupStart.Length, strLine.Length - StrGroupStart.Length - StrGroupEnd.Length); pwStorage.RootGroup.AddGroup(pg, true); } else if(strLine.StartsWith(StrEntryStart) && strLine.EndsWith(StrEntryEnd)) { AddEntry(pg, dItems, ref bInNotes); dItems.Clear(); } else if(strLine == StrNotesBegin) bInNotes = true; else if(bInNotes) { if(dItems.ContainsKey(PwDefs.NotesField)) dItems[PwDefs.NotesField] += MessageService.NewLine + strLine; else dItems[PwDefs.NotesField] = strLine; } else { int nSplitPos = strLine.IndexOf(StrFieldSplit); if(nSplitPos < 0) { Debug.Assert(false); } else { AddField(dItems, strLine.Substring(0, nSplitPos), strLine.Substring(nSplitPos + StrFieldSplit.Length)); } } } AddEntry(pg, dItems, ref bInNotes); }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.Unicode); string strData = sr.ReadToEnd(); sr.Close(); string[] vLines = strData.Split(new char[]{ '\r', '\n' }); foreach(string strLine in vLines) { if(strLine.Length == 0) continue; string[] vParts = strLine.Split(new char[]{ 'µ' }); PwEntry pe = new PwEntry(true, true); PwGroup pgContainer = pwStorage.RootGroup; string strNotes = string.Empty; for(int i = 0; i < vParts.Length; ++i) { switch(i) { case 0: // Empty field break; case 1: pgContainer = pwStorage.RootGroup.FindCreateSubTree( vParts[i], new char[]{ '.' }); break; case 2: pe.Strings.Set(PwDefs.TitleField, new ProtectedString( pwStorage.MemoryProtection.ProtectTitle, vParts[i])); break; case 3: pe.Strings.Set(PwDefs.UserNameField, new ProtectedString( pwStorage.MemoryProtection.ProtectUserName, vParts[i])); break; case 4: pe.Strings.Set(PwDefs.PasswordField, new ProtectedString( pwStorage.MemoryProtection.ProtectPassword, vParts[i])); break; case 5: strNotes += vParts[i].Replace("\\n", "\n"); break; default: strNotes += @"µ" + vParts[i].Replace("\\n", "\n"); break; } } pe.Strings.Set(PwDefs.NotesField, new ProtectedString( pwStorage.MemoryProtection.ProtectNotes, strNotes)); pgContainer.AddEntry(pe, true); } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.Default); string strData = sr.ReadToEnd(); sr.Close(); // Normalize 2.70 files strData = strData.Replace("<td class=\"c1\" nowrap>", m_strStartTd); strData = strData.Replace("<td class=\"c2\" nowrap>", m_strStartTd); strData = strData.Replace("<td class=\"c3\" nowrap>", m_strStartTd); strData = strData.Replace("<td class=\"c4\" nowrap>", m_strStartTd); strData = strData.Replace("<td class=\"c5\" nowrap>", m_strStartTd); strData = strData.Replace("<td class=\"c6\" nowrap>", m_strStartTd); // Additionally support old versions string[] vRepl = new string[5] { // 2.60 "<td nowrap align=\"center\" bgcolor=\"#[0-9a-fA-F]{6}\"><font color=\"#[0-9a-fA-F]{6}\" face=\"[^\"]*\">", // 2.50 and 2.60 "<td nowrap align=\"(center|right)\" bgcolor=\"#[0-9a-fA-F]{6}\"><font color=\"#[0-9a-fA-F]{6}\"\\s*>", "<td nowrap bgcolor=\"#[0-9a-fA-F]{6}\"><font color=\"#[0-9a-fA-F]{6}\"\\s*>", "<td nowrap align=\"(center|right)\" bgcolor=\"#[0-9a-fA-F]{6}\"><b>", "<td nowrap bgcolor=\"#[0-9a-fA-F]{6}\"><b>" }; foreach(string strRepl in vRepl) strData = Regex.Replace(strData, strRepl, m_strStartTd); strData = strData.Replace("</font></td>\r\n", m_strEndTd + "\r\n"); int nOffset = 0; PwEntry peHeader; if(!ReadEntry(out peHeader, strData, ref nOffset, pwStorage)) { Debug.Assert(false); return; } while((nOffset >= 0) && (nOffset < strData.Length)) { PwEntry pe; if(!ReadEntry(out pe, strData, ref nOffset, pwStorage)) { Debug.Assert(false); break; } if(pe == null) break; pwStorage.RootGroup.AddEntry(pe, true); } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { MemoryStream ms = new MemoryStream(); MemUtil.CopyStream(sInput, ms); byte[] pbData = ms.ToArray(); ms.Close(); sInput.Close(); CsvImportForm dlg = new CsvImportForm(); dlg.InitEx(pwStorage, pbData); UIUtil.ShowDialogAndDestroy(dlg); }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.UTF8); string strDoc = sr.ReadToEnd(); sr.Close(); XmlDocument doc = new XmlDocument(); doc.LoadXml(strDoc); ProcessEntries(pwStorage, pwStorage.RootGroup, doc.DocumentElement.ChildNodes); }
public override bool Export(PwExportInfo pwExportInfo, Stream sOutput, IStatusLogger slLogger) { string strXslFile; pwExportInfo.Parameters.TryGetValue(ParamXslFile, out strXslFile); if(string.IsNullOrEmpty(strXslFile)) strXslFile = UIGetXslFile(); if(string.IsNullOrEmpty(strXslFile)) return false; return ExportEx(pwExportInfo, sOutput, slLogger, strXslFile); }
private bool ExportEx(PwExportInfo pwExportInfo, Stream sOutput, IStatusLogger slLogger, string strXslFile) { XslCompiledTransform xsl = new XslCompiledTransform(); try { xsl.Load(strXslFile); } catch(Exception exXsl) { throw new NotSupportedException(strXslFile + MessageService.NewParagraph + KPRes.NoXslFile + MessageService.NewParagraph + exXsl.Message); } byte[] pbData; using(MemoryStream ms = new MemoryStream()) { PwDatabase pd = (pwExportInfo.ContextDatabase ?? new PwDatabase()); KdbxFile f = new KdbxFile(pd); f.Save(ms, pwExportInfo.DataGroup, KdbxFormat.PlainXml, slLogger); pbData = ms.ToArray(); } if(pbData == null) throw new OutOfMemoryException(); XmlWriterSettings xws = xsl.OutputSettings; if(xws == null) { xws = new XmlWriterSettings(); xws.CheckCharacters = false; xws.ConformanceLevel = ConformanceLevel.Auto; xws.Encoding = StrUtil.Utf8; // xws.Indent = false; xws.IndentChars = "\t"; xws.NewLineChars = MessageService.NewLine; xws.NewLineHandling = NewLineHandling.None; xws.OmitXmlDeclaration = true; } using(MemoryStream msIn = new MemoryStream(pbData, false)) { using(XmlReader xrIn = XmlReader.Create(msIn)) { using(XmlWriter xwOut = XmlWriter.Create(sOutput, xws)) { xsl.Transform(xrIn, xwOut); } } } MemUtil.ZeroByteArray(pbData); return true; }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.Default); string strData = sr.ReadToEnd(); sr.Close(); string[] vLines = strData.Split(new char[] { '\r', '\n' }); foreach(string strLine in vLines) { if(strLine.Length > 5) ProcessCsvLine(strLine, pwStorage); } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.UTF8); string strContent = sr.ReadToEnd(); sr.Close(); if(strContent.IndexOf(@"<!DOCTYPE NETSCAPE-Bookmark-file-1>") < 0) throw new FormatException("Invalid DOCTYPE!"); strContent = strContent.Replace(@"<!DOCTYPE NETSCAPE-Bookmark-file-1>", string.Empty); strContent = strContent.Replace(@"<HR>", string.Empty); strContent = strContent.Replace(@"<p>", string.Empty); strContent = strContent.Replace(@"<DD>", string.Empty); strContent = strContent.Replace(@"<DL>", string.Empty); strContent = strContent.Replace(@"</DL>", string.Empty); strContent = strContent.Replace(@"<DT>", string.Empty); int nOffset = strContent.IndexOf('&'); while(nOffset >= 0) { string str4 = strContent.Substring(nOffset, 4); string str5 = strContent.Substring(nOffset, 5); string str6 = strContent.Substring(nOffset, 6); if((str6 != @" ") && (str5 != @"&") && (str4 != @"<") && (str4 != @">") && (str5 != @"'") && (str6 != @""")) { strContent = strContent.Remove(nOffset, 1); strContent = strContent.Insert(nOffset, @"&"); } else nOffset = strContent.IndexOf('&', nOffset + 1); } strContent = "<RootSentinel>" + strContent + "</META></RootSentinel>"; byte[] pbFixedData = StrUtil.Utf8.GetBytes(strContent); MemoryStream msFixed = new MemoryStream(pbFixedData, false); XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(msFixed); msFixed.Close(); XmlNode xmlRoot = xmlDoc.DocumentElement; foreach(XmlNode xmlChild in xmlRoot) { if(xmlChild.Name == "META") ImportLinksFlat(xmlChild, pwStorage); } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(sInput); XmlNode xmlRoot = xmlDoc.DocumentElement; foreach(XmlNode xmlChild in xmlRoot.ChildNodes) { if(xmlChild.Name == ElemGroup) ReadGroup(xmlChild, pwStorage.RootGroup, pwStorage); else { Debug.Assert(false); } } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { string strTempFile = Program.TempFilesPool.GetTempFileName(); BinaryReader br = new BinaryReader(sInput); byte[] pb = br.ReadBytes((int)sInput.Length); br.Close(); File.WriteAllBytes(strTempFile, pb); Kdb3File kdb3 = new Kdb3File(pwStorage, slLogger); kdb3.Load(strTempFile); Program.TempFilesPool.Delete(strTempFile); }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.UTF8); string strFileContents = sr.ReadToEnd(); sr.Close(); CharStream csSource = new CharStream(strFileContents); while(true) { if(ReadEntry(pwStorage, csSource) == false) break; } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.UTF8); string strContent = sr.ReadToEnd(); sr.Close(); if(strContent.Length == 0) return; CharStream cs = new CharStream(strContent); JsonObject jRoot = new JsonObject(cs); AddObject(pwStorage.RootGroup, jRoot, pwStorage, false); Debug.Assert(cs.PeekChar(true) == char.MinValue); }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { string str = PwMemory2008Xml104.Preprocess(sInput); MemoryStream ms = new MemoryStream(StrUtil.Utf8.GetBytes(str), false); XmlSerializer xs = new XmlSerializer(typeof(Priv_PwMem2008XmlFile)); Priv_PwMem2008XmlFile f = (Priv_PwMem2008XmlFile)xs.Deserialize(ms); ms.Close(); if((f == null) || (f.Cells == null)) return; Dictionary<string, PwGroup> vGroups = new Dictionary<string, PwGroup>(); for(int iLine = 2; iLine < f.Cells.Length; ++iLine) { string[] vCells = f.Cells[iLine]; if((vCells == null) || (vCells.Length != 6)) continue; if((vCells[1] == null) || (vCells[2] == null) || (vCells[3] == null) || (vCells[4] == null)) continue; string strGroup = vCells[4]; PwGroup pg; if(strGroup == ".") pg = pwStorage.RootGroup; else if(vGroups.ContainsKey(strGroup)) pg = vGroups[strGroup]; else { pg = new PwGroup(true, true); pg.Name = strGroup; pwStorage.RootGroup.AddGroup(pg, true); vGroups[strGroup] = pg; } PwEntry pe = new PwEntry(true, true); pg.AddEntry(pe, true); if(vCells[1] != ".") pe.Strings.Set(PwDefs.TitleField, new ProtectedString( pwStorage.MemoryProtection.ProtectTitle, vCells[1])); if(vCells[2] != ".") pe.Strings.Set(PwDefs.UserNameField, new ProtectedString( pwStorage.MemoryProtection.ProtectUserName, vCells[2])); if(vCells[3] != ".") pe.Strings.Set(PwDefs.PasswordField, new ProtectedString( pwStorage.MemoryProtection.ProtectPassword, vCells[3])); } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(sInput); XmlNode xmlRoot = xmlDoc.DocumentElement; foreach(XmlNode xmlChild in xmlRoot.ChildNodes) { if(xmlChild.Name == ElemHeader) { } // Unsupported else if(xmlChild.Name == ElemContainer) ReadContainer(xmlChild, pwStorage); else { Debug.Assert(false); } } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.Default, true); string strData = sr.ReadToEnd(); sr.Close(); string[] vLines = strData.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); Dictionary<string, PwGroup> dictGroups = new Dictionary<string, PwGroup>(); foreach(string strLine in vLines) { ProcessCsvLine(strLine, pwStorage, dictGroups); } }
public override bool Export(PwExportInfo pwExportInfo, Stream sOutput, IStatusLogger slLogger) { string strXslFile; pwExportInfo.Parameters.TryGetValue(ParamXslFile, out strXslFile); if (string.IsNullOrEmpty(strXslFile)) { strXslFile = UIGetXslFile(); } if (string.IsNullOrEmpty(strXslFile)) { return(false); } return(ExportEx(pwExportInfo, sOutput, slLogger, strXslFile)); }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.Default); string strData = sr.ReadToEnd(); sr.Close(); string[] vLines = strData.Split(new char[] { '\r', '\n' }); foreach (string strLine in vLines) { if (strLine.Length > 5) { ProcessCsvLine(strLine, pwStorage); } } }
/// <summary> /// Open a database. The URL may point to any supported data source. /// </summary> /// <param name="ioSource">IO connection to load the database from.</param> /// <param name="pwKey">Key used to open the specified database.</param> /// <param name="slLogger">Logger, which gets all status messages.</param> public void Open(IOConnectionInfo ioSource, CompositeKey pwKey, IStatusLogger slLogger) { Debug.Assert(ioSource != null); if (ioSource == null) { throw new ArgumentNullException("ioSource"); } Debug.Assert(pwKey != null); if (pwKey == null) { throw new ArgumentNullException("pwKey"); } this.Close(); try { m_pgRootGroup = new PwGroup(true, true, UrlUtil.StripExtension( UrlUtil.GetFileName(ioSource.Path)), PwIcon.FolderOpen); m_pgRootGroup.IsExpanded = true; m_pwUserKey = pwKey; m_bModified = false; Kdb4File kdb4 = new Kdb4File(this); Stream s = IOConnection.OpenRead(ioSource); kdb4.Load(s, Kdb4Format.Default, slLogger); s.Close(); m_pbHashOfLastIO = kdb4.HashOfFileOnDisk; m_pbHashOfFileOnDisk = kdb4.HashOfFileOnDisk; Debug.Assert(m_pbHashOfFileOnDisk != null); m_bDatabaseOpened = true; m_ioSource = ioSource; } catch (Exception) { this.Clear(); throw; } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { JsonObject jo; using (StreamReader sr = new StreamReader(sInput, StrUtil.Utf8, true)) { string strJson = sr.ReadToEnd(); if (string.IsNullOrEmpty(strJson)) { return; } jo = new JsonObject(new CharStream(strJson)); } Dictionary <string, List <string> > dTags = new Dictionary <string, List <string> >(); List <PwEntry> lCreatedEntries = new List <PwEntry>(); AddObject(pwStorage.RootGroup, jo, pwStorage, false, dTags, lCreatedEntries); // Tags support (old versions) foreach (PwEntry pe in lCreatedEntries) { string strUri = pe.Strings.ReadSafe(PwDefs.UrlField); if (strUri.Length == 0) { continue; } foreach (KeyValuePair <string, List <string> > kvp in dTags) { foreach (string strTagUri in kvp.Value) { if (strUri.Equals(strTagUri, StrUtil.CaseIgnoreCmp)) { pe.AddTag(kvp.Key); } } } } }
/// <summary>Writes to a xml file</summary> /// <param name="pwExportInfo">The information to be exported</param> /// <param name="sOutput">A stream to the xml file/entry</param> /// <param name="slLogger">Logger to be used</param> public override bool Export(PwExportInfo pwExportInfo, Stream sOutput, IStatusLogger slLogger) { XmlSerializer xml = new XmlSerializer(typeof(WlanProfile)); WlanProfile curProfile = new WlanProfile(); if (slLogger != null) { slLogger.SetText("Schreibe XML", LogStatusType.Info); slLogger.SetProgress(0); } double progress = 0; String name; foreach (PwEntry entry in pwExportInfo.DataGroup.GetEntries(true)) { if (slLogger != null) { name = entry.Strings.Get(PwDefs.TitleField).ReadString(); if ((name == null) || (name.Length == 0)) { name = entry.Strings.Get(FieldNames.SSID).ReadString(); if ((name == null) || (name.Length == 0)) { continue; } } slLogger.SetText(String.Format("Schreibe Wifi-Information {0}", name), LogStatusType.Info); progress += 50 / pwExportInfo.DataGroup.GetEntriesCount(true); slLogger.SetProgress((uint)progress); } curProfile.LoadFrom(pwExportInfo.ContextDatabase, entry); xml.Serialize(sOutput, curProfile); if (slLogger != null) { progress += 50 / pwExportInfo.DataGroup.GetEntriesCount(true); slLogger.SetProgress((uint)progress); } } return(true); }
public override bool Export(PwExportInfo pwExportInfo, Stream sOutput, IStatusLogger slLogger) { PwGroup pg = pwExportInfo.DataGroup; if (pg == null) { Debug.Assert(false); return(true); } string strBaseName = FilterFileName(string.IsNullOrEmpty( Program.Config.Defaults.WinFavsBaseFolderName) ? PwDefs.ShortProductName : Program.Config.Defaults.WinFavsBaseFolderName); string strRootName = strBaseName + " - " + FilterFileName(pg.Name); if (pwExportInfo.ContextDatabase != null) { if (pg == pwExportInfo.ContextDatabase.RootGroup) { strRootName = strBaseName; } } string strFavsRoot = Environment.GetFolderPath( Environment.SpecialFolder.Favorites); if (string.IsNullOrEmpty(strFavsRoot)) { return(false); } string strFavsSub = UrlUtil.EnsureTerminatingSeparator(strFavsRoot, false) + strRootName; if (Directory.Exists(strFavsSub)) { Directory.Delete(strFavsSub, true); WaitForDirCommit(strFavsSub, false); } ExportGroup(pwExportInfo.DataGroup, strFavsSub); return(true); }
/// <summary> /// Exports a wlan connection information from the database to a .xml profil. /// </summary> /// <param name="pwStorage">The database in which the key lies</param> /// <param name="entry">The entry which we want to export</param> /// <param name="soutput">Where to print to the xml structure (via serialization)</param> /// <param name="slLogger">Where we log to (can be null)</param> /// <param name="totalProcents">If we parsed completely, how many (additional) procents of the /// total progress did we finish? (Senseless if slLogger = null)</param> /// <param name="minProcents">How many procents of the total progress were already finished</param> /// <remarks>Note that minProcents + totalProcents has to be less than or equal to 100. /// <para>Note furthermore that nothing is written to soutput if an error occured</para></remarks> /// <returns>Whether the export was successfull.</returns> public bool Export(PwDatabase pwStorage, PwEntry entry, Stream sOutput, IStatusLogger slLogger = null, double totalProcents = 60, double minProcents = 20) { WlanProfile profile = new WlanProfile(); profile.LoadFrom(pwStorage, entry); if (!profile.IsValid) { return(false); } XmlSerializer xml = new XmlSerializer(typeof(WlanProfile)); xml.Serialize(sOutput, profile); return(true); }
private bool ExportEx(PwExportInfo pwExportInfo, Stream sOutput, IStatusLogger slLogger, string strXslFile) { XslCompiledTransform xsl = new XslCompiledTransform(); try { xsl.Load(strXslFile); } catch (Exception exXsl) { throw new NotSupportedException(strXslFile + MessageService.NewParagraph + KPRes.NoXslFile + MessageService.NewParagraph + exXsl.Message); } MemoryStream msDataXml = new MemoryStream(); PwDatabase pd = (pwExportInfo.ContextDatabase ?? new PwDatabase()); KdbxFile kdb = new KdbxFile(pd); kdb.Save(msDataXml, pwExportInfo.DataGroup, KdbxFormat.PlainXml, slLogger); byte[] pbData = msDataXml.ToArray(); msDataXml.Close(); MemoryStream msDataRead = new MemoryStream(pbData, false); XmlReader xmlDataReader = XmlReader.Create(msDataRead); XmlWriterSettings xws = new XmlWriterSettings(); xws.CheckCharacters = false; xws.Encoding = new UTF8Encoding(false); xws.NewLineChars = MessageService.NewLine; xws.NewLineHandling = NewLineHandling.None; xws.OmitXmlDeclaration = true; xws.ConformanceLevel = ConformanceLevel.Auto; XmlWriter xmlWriter = XmlWriter.Create(sOutput, xws); xsl.Transform(xmlDataReader, xmlWriter); xmlWriter.Close(); xmlDataReader.Close(); msDataRead.Close(); Array.Clear(pbData, 0, pbData.Length); return(true); }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.Default); string strData = sr.ReadToEnd(); sr.Close(); const string strNormalized = "<td class=\"c0\" nowrap>"; strData = strData.Replace("<td class=\"c1\" nowrap>", strNormalized); strData = strData.Replace("<td class=\"c2\" nowrap>", strNormalized); strData = strData.Replace("<td class=\"c3\" nowrap>", strNormalized); strData = strData.Replace("<td class=\"c4\" nowrap>", strNormalized); strData = strData.Replace("<td class=\"c5\" nowrap>", strNormalized); strData = strData.Replace("<td class=\"c6\" nowrap>", strNormalized); int nOffset = 0; PwEntry peHeader; if (ReadEntry(out peHeader, strData, ref nOffset, pwStorage) == false) { Debug.Assert(false); return; } while ((nOffset >= 0) && (nOffset < strData.Length)) { PwEntry pe; if (ReadEntry(out pe, strData, ref nOffset, pwStorage) == false) { Debug.Assert(false); break; } if (pe == null) { break; } pwStorage.RootGroup.AddEntry(pe, true); } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { if (MessageService.AskYesNo(KPRes.ImportMustRead + MessageService.NewParagraph + KPRes.ImportMustReadQuestion) == false) { AppHelp.ShowHelp(AppDefs.HelpTopics.ImportExport, AppDefs.HelpTopics.ImportExportSteganos); return; } PwEntry pePrev = new PwEntry(true, true); for (int i = 0; i < 20; ++i) { Thread.Sleep(500); Application.DoEvents(); } try { while (true) { PwEntry pe = ImportEntry(pwStorage); if (ImportUtil.EntryEquals(pe, pePrev)) { if (pe.ParentGroup != null) // Remove duplicate { pe.ParentGroup.Entries.Remove(pe); } break; } ImportUtil.GuiSendKeysPrc(@"{DOWN}"); pePrev = pe; } MessageService.ShowInfo(KPRes.ImportFinished); } catch (Exception exImp) { MessageService.ShowWarning(exImp); } }
/// <summary> /// Save the currently opened database. The file is written to the location /// it has been opened from. /// </summary> /// <param name="slLogger">Logger that recieves status information.</param> public void Save(IStatusLogger slLogger) { bool bMadeUnhidden = UrlUtil.UnhideFile(m_ioSource.Path); Stream s = IOConnection.OpenWrite(m_ioSource); Kdb4File kdb = new Kdb4File(this); kdb.Save(s, null, Kdb4Format.Default, slLogger); if (bMadeUnhidden) { UrlUtil.HideFile(m_ioSource.Path, true); // Hide again } m_pbHashOfLastIO = kdb.HashOfFileOnDisk; m_pbHashOfFileOnDisk = kdb.HashOfFileOnDisk; Debug.Assert(m_pbHashOfFileOnDisk != null); m_bModified = false; }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.Unicode, true); string strData = sr.ReadToEnd(); sr.Close(); strData = strData.Replace(@"<WBR>", string.Empty); strData = strData.Replace(@"­", string.Empty); using (WebBrowser wb = new WebBrowser()) { wb.Visible = false; wb.ScriptErrorsSuppressed = true; UIUtil.SetWebBrowserDocument(wb, strData); ImportPriv(pwStorage, wb.Document.Body); } }
public FaviconDialog(IPluginHost host) { // KeePass plugin host pluginHost = host; // Set up BackgroundWorker bgWorker = new BackgroundWorker(); // BackgroundWorker Events bgWorker.DoWork += BgWorker_DoWork; bgWorker.RunWorkerCompleted += BgWorker_RunWorkerCompleted; // Status Progress Form Form fStatusDialog; logger = StatusUtil.CreateStatusDialog(pluginHost.MainWindow, out fStatusDialog, "Yet Another Favicon Downloader", "Downloading favicons...", true, false); // Block UI pluginHost.MainWindow.UIBlockInteraction(true); }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, Encoding.UTF8); string strContent = sr.ReadToEnd(); sr.Close(); if (strContent.Length == 0) { return; } CharStream cs = new CharStream(strContent); JsonObject jRoot = new JsonObject(cs); AddObject(pwStorage.RootGroup, jRoot, pwStorage, false); Debug.Assert(cs.PeekChar(true) == char.MinValue); }
public static async Task ProcessSignonsAsync( IEnumerable <Signon> signons, ImportDialog form, PwDatabase db, IStatusLogger logger) { logger.SetText("Processing signons", LogStatusType.Info); List <Task> tasks = signons.Select(signon => AddEntryAsync(signon, form, db, logger)).ToList(); int total = tasks.Count; var progress = 0; while (tasks.Count > 0) { Task completedTask = Task.Factory.ContinueWhenAny(tasks.ToArray(), task => tasks.Remove(task)); await completedTask.ConfigureAwait(false); ++progress; logger.SetProgress((uint)(100 * (double)progress / total)); } }
public override bool Export(PwExportInfo pwExportInfo, Stream sOutput, IStatusLogger slLogger) { PrintForm dlg = new PrintForm(); dlg.InitEx(pwExportInfo.DataGroup, false, -1); bool bResult = false; if (dlg.ShowDialog() == DialogResult.OK) { byte[] pb = StrUtil.Utf8.GetBytes(dlg.GeneratedHtml); sOutput.Write(pb, 0, pb.Length); sOutput.Close(); bResult = true; } UIUtil.DestroyForm(dlg); return(bResult); }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(sInput); XmlNode xmlRoot = xmlDoc.DocumentElement; foreach (XmlNode xmlChild in xmlRoot.ChildNodes) { if (xmlChild.Name == ElemGroup) { ReadGroup(xmlChild, pwStorage.RootGroup, pwStorage); } else { Debug.Assert(false); } } }
private void OTPDB_Save() { if (!Valid || !OTPDB_Opened || !OTPDB.Modified) { return; } OTPDB.Modified = false; UpdateDBHeader(); PwExportInfo pei = new PwExportInfo(OTPDB.RootGroup, OTPDB); using (var s = new MemoryStream()) { IStatusLogger sl = Program.MainForm.CreateShowWarningsLogger(); sl.StartLogging(PluginTranslate.OTPDB_Save, true); m_FFP.Export(pei, s, sl); sl.EndLogging(); s.Flush(); SetOTPDBData(s.GetBuffer()); } FlagChanged(false); }
internal static void ShowLoadError(string strPath, Exception ex, IStatusLogger slStatus) { if (string.IsNullOrEmpty(strPath)) { Debug.Assert(false); return; } if (slStatus != null) { slStatus.SetText(KPRes.PluginLoadFailed, LogStatusType.Info); } bool bShowExcp = (Program.CommandLineArgs[ AppDefs.CommandLineOptions.Debug] != null); string strMsg = KPRes.PluginIncompatible + MessageService.NewLine + strPath + MessageService.NewParagraph + KPRes.PluginUpdateHint; string strExcp = ((ex != null) ? StrUtil.FormatException(ex).Trim() : null); VistaTaskDialog vtd = new VistaTaskDialog(); vtd.Content = strMsg; vtd.ExpandedByDefault = ((strExcp != null) && bShowExcp); vtd.ExpandedInformation = strExcp; vtd.WindowTitle = PwDefs.ShortProductName; vtd.SetIcon(VtdIcon.Warning); if (!vtd.ShowDialog()) { if (!bShowExcp) { MessageService.ShowWarning(strMsg); } else { MessageService.ShowWarningExcp(strPath, ex); } } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { var form = new OptionForm(); if (form.ShowDialog() != DialogResult.OK) { return; } slLogger.SetText("Decrypting backup...", LogStatusType.Info); var pfp = new PfpConvert(); var protect = Util.GetMemoryProtection(pwStorage.MemoryProtection); protect.Add("PIN"); protect.Add("PUK"); protect.Add("CVV"); var entries = pfp.Load(sInput, form.MasterPassword); var pw = pfp.GetPasswordGetter(form.MasterPassword); var i = 0; foreach (var baseentry in entries) { if (!(baseentry is PassEntry entry)) { continue; } slLogger.SetText($"Importing {entry.name}@{entry.site}...", LogStatusType.Info); var pwEntry = Util.GetKeepassEntry(entry, pw, protect); pwStorage.RootGroup.AddEntry(pwEntry, true); i++; } slLogger.SetText($"Imported {i} entries.", LogStatusType.Info); }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { byte[] pb = MemUtil.Read(sInput); if (ImportOld(pwStorage, pb)) { return; } XmlDocument d = XmlUtilEx.CreateXmlDocument(); using (MemoryStream ms = new MemoryStream(pb, false)) { using (StreamReader sr = new StreamReader(ms, StrUtil.Utf8, true)) { d.Load(sr); } } XmlNode xmlRoot = d.DocumentElement; Debug.Assert(xmlRoot.Name == "data"); foreach (XmlNode xmlChild in xmlRoot.ChildNodes) { if (xmlChild.Name == ElemGroup) { ReadGroup(xmlChild, pwStorage.RootGroup, pwStorage); } else if (xmlChild.Name == ElemEntry) { ReadEntry(xmlChild, pwStorage.RootGroup, pwStorage); } else { Debug.Assert(false); } } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { var entries = new List <Entry>(); var name = GetName(sInput); var rootGroup = CreateGroup(pwStorage, name); using (var reader = new StreamReader(sInput, System.Text.Encoding.UTF8)) { while (!reader.EndOfStream) { var entry = Entry.Read(reader); entries.Add(entry); } } for (int i = 0; i < entries.Count; i++) { var entry = entries[i]; slLogger.SetText(string.Format("{0} ({1} of {2})", entry.Name, i + 1, entries.Count), LogStatusType.Info); AddEntry(pwStorage, rootGroup, entry); } }
public static void Load(string strFilePath, IStatusLogger slStatus) { try { LoadPriv(strFilePath, slStatus, true, true, true, null); } catch (PlgxException exPlgx) { MessageService.ShowWarning(strFilePath + MessageService.NewParagraph + KPRes.PluginLoadFailed + MessageService.NewParagraph + exPlgx.Message); } catch (Exception exLoad) { if (Program.CommandLineArgs[AppDefs.CommandLineOptions.Debug] != null) { MessageService.ShowWarningExcp(strFilePath, exLoad); } else { MessageService.ShowWarning(KPRes.PluginIncompatible + MessageService.NewLine + strFilePath, KPRes.PluginUpdateHint); } } }
DownloadInfoFiles(List<string> lUrls, IStatusLogger sl) { List<UpdateDownloadInfo> lDl = new List<UpdateDownloadInfo>(); foreach(string strUrl in lUrls) { if(string.IsNullOrEmpty(strUrl)) { Debug.Assert(false); continue; } UpdateDownloadInfo dl = new UpdateDownloadInfo(strUrl); lDl.Add(dl); ThreadPool.QueueUserWorkItem(new WaitCallback( UpdateCheckEx.DownloadInfoFile), dl); } while(true) { bool bReady = true; foreach(UpdateDownloadInfo dl in lDl) { lock(dl.SyncObj) { bReady &= dl.Ready; } } if(bReady) break; Thread.Sleep(40); if(sl != null) { if(!sl.ContinueWork()) return null; } } Dictionary<string, List<UpdateComponentInfo>> dict = new Dictionary<string, List<UpdateComponentInfo>>(); foreach(UpdateDownloadInfo dl in lDl) { dict[dl.Url.ToLower()] = dl.ComponentInfo; } return dict; }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, StrUtil.Utf8); string strDoc = sr.ReadToEnd(); sr.Close(); XmlDocument doc = new XmlDocument(); doc.LoadXml(strDoc); XmlElement xmlRoot = doc.DocumentElement; Debug.Assert(xmlRoot.Name == ElemRoot); PwGroup pgRoot = pwStorage.RootGroup; foreach (XmlNode xmlChild in xmlRoot.ChildNodes) { if (xmlChild.Name == ElemGroup) { ImportGroup(xmlChild, pgRoot, pwStorage, false); } else if (xmlChild.Name == ElemRecycleBin) { ImportGroup(xmlChild, pgRoot, pwStorage, true); } else if (xmlChild.Name == ElemEntry) { ImportEntry(xmlChild, pgRoot, pwStorage); } else { Debug.Assert(false); } } }
public override bool Export(PwExportInfo pwExportInfo, Stream sOutput, IStatusLogger slLogger) { var form = new OptionForm(); if (form.ShowDialog() != DialogResult.OK) { return(false); } slLogger.SetText("Collecting entries...", LogStatusType.Info); var entries = ConvertGroup(pwExportInfo.DataGroup, slLogger); slLogger.SetText("Encrypting backup...", LogStatusType.Info); var pfp = new PfpConvert(); pfp.Save(sOutput, form.MasterPassword, entries); slLogger.SetText($"Exported {entries.Count} entries.", LogStatusType.Info); return(true); }
/// <summary> /// Save the currently opened database. The file is written to the location /// it has been opened from. /// </summary> /// <param name="slLogger">Logger that recieves status information.</param> public void Save(IStatusLogger slLogger) { Debug.Assert(ValidateUuidUniqueness()); // bool bMadeUnhidden = UrlUtil.UnhideFile(m_ioSource.Path); // Stream s = IOConnection.OpenWrite(m_ioSource); FileTransactionEx ft = new FileTransactionEx(m_ioSource, m_bUseFileTransactions); Stream s = ft.OpenWrite(); Kdb4File kdb = new Kdb4File(this); kdb.Save(s, null, Kdb4Format.Default, slLogger); ft.CommitWrite(); // if(bMadeUnhidden) UrlUtil.HideFile(m_ioSource.Path, true); // Hide again m_pbHashOfLastIO = kdb.HashOfFileOnDisk; m_pbHashOfFileOnDisk = kdb.HashOfFileOnDisk; Debug.Assert(m_pbHashOfFileOnDisk != null); m_bModified = false; }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { string strAll; using (StreamReader sr = new StreamReader(sInput, Encoding.UTF8, true)) { strAll = sr.ReadToEnd(); } // Fix new-line sequences and normalize to '\n' strAll = strAll.Replace("\r\r\n", "\r\n"); strAll = StrUtil.NormalizeNewLines(strAll, false); string[] vBlocks = strAll.Split(new string[] { "\n\n---\n\n" }, StringSplitOptions.None); PwGroup pg = pwStorage.RootGroup; foreach (string strBlock in vBlocks) { ImportBlock(pwStorage, ref pg, strBlock); } }
public override void Import(PwDatabase pwStorage, Stream sInput, IStatusLogger slLogger) { StreamReader sr = new StreamReader(sInput, StrUtil.Utf8, true); string strData = sr.ReadToEnd(); sr.Close(); // The Chrome extension of LastPass 4.1.35 encodes some // special characters as XML entities; the web version and // the Firefox extension do not do this strData = strData.Replace(@"<", @"<"); strData = strData.Replace(@">", @">"); strData = strData.Replace(@"&", @"&"); CsvOptions opt = new CsvOptions(); opt.BackslashIsEscape = false; CsvStreamReaderEx csr = new CsvStreamReaderEx(strData, opt); ImportCsv(csr, pwStorage); }
public override void Import(PwDatabase pwStorage, System.IO.Stream sInput, IStatusLogger slLogger) { var document = new XmlDocument(); document.Load(sInput); var root = document.DocumentElement; var products = root.SelectNodes("Product_Key"); if (products == null || products.Count == 0) { return; } var msdnGroup = pwStorage.RootGroup.FindCreateGroup("Microsoft Product Keys", true); for (int i = 0; i < products.Count; i++) { var product = new Product(products[i]); slLogger.SetText(string.Format("{0} ({1} of {2})", product.Name, i + 1, products.Count), LogStatusType.Info); AddProduct(pwStorage, msdnGroup, product); } }