private static void TestProtectedObjects()
{
#if DEBUG
Encoding enc = StrUtil.Utf8;
byte[] pbData = enc.GetBytes("Test Test Test Test");
ProtectedBinary pb = new ProtectedBinary(true, pbData);
if (!pb.IsProtected)
{
throw new SecurityException("ProtectedBinary-1");
}
byte[] pbDec = pb.ReadData();
if (!MemUtil.ArraysEqual(pbData, pbDec))
{
throw new SecurityException("ProtectedBinary-2");
}
if (!pb.IsProtected)
{
throw new SecurityException("ProtectedBinary-3");
}
byte[] pbData2 = enc.GetBytes("Test Test Test Test");
byte[] pbData3 = enc.GetBytes("Test Test Test Test Test");
ProtectedBinary pb2 = new ProtectedBinary(true, pbData2);
ProtectedBinary pb3 = new ProtectedBinary(true, pbData3);
if (!pb.Equals(pb2))
{
throw new SecurityException("ProtectedBinary-4");
}
if (pb.Equals(pb3))
{
throw new SecurityException("ProtectedBinary-5");
}
if (pb2.Equals(pb3))
{
throw new SecurityException("ProtectedBinary-6");
}
if (pb.GetHashCode() != pb2.GetHashCode())
{
throw new SecurityException("ProtectedBinary-7");
}
if (!((object)pb).Equals((object)pb2))
{
throw new SecurityException("ProtectedBinary-8");
}
if (((object)pb).Equals((object)pb3))
{
throw new SecurityException("ProtectedBinary-9");
}
if (((object)pb2).Equals((object)pb3))
{
throw new SecurityException("ProtectedBinary-10");
}
ProtectedString ps = new ProtectedString();
if (ps.Length != 0)
{
throw new SecurityException("ProtectedString-1");
}
if (!ps.IsEmpty)
{
throw new SecurityException("ProtectedString-2");
}
if (ps.ReadString().Length != 0)
{
throw new SecurityException("ProtectedString-3");
}
ps = new ProtectedString(true, "Test");
ProtectedString ps2 = new ProtectedString(true, enc.GetBytes("Test"));
if (ps.IsEmpty)
{
throw new SecurityException("ProtectedString-4");
}
pbData = ps.ReadUtf8();
pbData2 = ps2.ReadUtf8();
if (!MemUtil.ArraysEqual(pbData, pbData2))
{
throw new SecurityException("ProtectedString-5");
}
if (pbData.Length != 4)
{
throw new SecurityException("ProtectedString-6");
}
if (ps.ReadString() != ps2.ReadString())
{
throw new SecurityException("ProtectedString-7");
}
pbData = ps.ReadUtf8();
pbData2 = ps2.ReadUtf8();
if (!MemUtil.ArraysEqual(pbData, pbData2))
{
throw new SecurityException("ProtectedString-8");
}
if (!ps.IsProtected)
{
throw new SecurityException("ProtectedString-9");
}
if (!ps2.IsProtected)
{
throw new SecurityException("ProtectedString-10");
}
#endif
}
private static ProtectedBinary DecryptSecret(byte[] encryptedSecret, ProtectedBinary key, byte[] iv)
{
using var ms = new MemoryStream(encryptedSecret);
using var decryptionStream = new StandardAesEngine().DecryptStream(ms, key.ReadData(), iv);
return(new ProtectedBinary(true, ReadToEnd(decryptionStream)));
}
private static void SaveBinary(string strName, ProtectedBinary pb,
string strSaveDir)
{
if (pb == null)
{
Debug.Assert(false); return;
}
strName = UrlUtil.GetSafeFileName(strName);
string strPath;
int iTry = 1;
do
{
strPath = UrlUtil.EnsureTerminatingSeparator(strSaveDir, false);
string strDesc = UrlUtil.StripExtension(strName);
string strExt = UrlUtil.GetExtension(strName);
strPath += strDesc;
if (iTry > 1)
{
strPath += " (" + iTry.ToString(NumberFormatInfo.InvariantInfo) +
")";
}
if (!string.IsNullOrEmpty(strExt))
{
strPath += "." + strExt;
}
++iTry;
}
#if ModernKeePassLib
while (StorageFile.GetFileFromPathAsync(strPath).GetResults() != null);
#else
while(File.Exists(strPath));
#endif
#if ModernKeePassLib
byte[] pbData = pb.ReadData();
/*var file = FileSystem.Current.GetFileFromPathAsync(strPath).Result;
* using (var stream = file.OpenAsync(FileAccess.ReadAndWrite).Result) {*/
var file = StorageFile.GetFileFromPathAsync(strPath).GetAwaiter().GetResult();
using (var stream = file.OpenAsync(FileAccessMode.ReadWrite).GetAwaiter().GetResult().AsStream())
{
stream.Write(pbData, 0, pbData.Length);
}
MemUtil.ZeroByteArray(pbData);
#elif !KeePassLibSD
byte[] pbData = pb.ReadData();
File.WriteAllBytes(strPath, pbData);
MemUtil.ZeroByteArray(pbData);
#else
FileStream fs = new FileStream(strPath, FileMode.Create,
FileAccess.Write, FileShare.None);
byte[] pbData = pb.ReadData();
try { File.WriteAllBytes(strPath, pbData); }
finally { if (pb.IsProtected)
{
MemUtil.ZeroByteArray(pbData);
}
}
#endif
}
public static ProtectedBinary Open(string strName, ProtectedBinary pb,
BinaryDataOpenOptions opt)
{
if (string.IsNullOrEmpty(strName))
{
Debug.Assert(false); return(null);
}
if (pb == null)
{
Debug.Assert(false); return(null);
}
if (opt == null)
{
opt = new BinaryDataOpenOptions();
}
byte[] pbData = pb.ReadData();
if (pbData == null)
{
Debug.Assert(false); return(null);
}
BinaryDataHandler h = opt.Handler;
if (h == BinaryDataHandler.Default)
{
h = ChooseHandler(strName, pbData, opt);
}
byte[] pbModData = null;
if (h == BinaryDataHandler.InternalViewer)
{
DataViewerForm dvf = new DataViewerForm();
dvf.InitEx(strName, pbData);
UIUtil.ShowDialogAndDestroy(dvf);
}
else if (h == BinaryDataHandler.InternalEditor)
{
DataEditorForm def = new DataEditorForm();
def.InitEx(strName, pbData);
def.ShowDialog();
if (def.EditedBinaryData != null)
{
pbModData = def.EditedBinaryData;
}
UIUtil.DestroyForm(def);
}
else if (h == BinaryDataHandler.ExternalApp)
{
pbModData = OpenExternal(strName, pbData, opt);
}
else
{
Debug.Assert(false);
}
if ((pbModData != null) && !MemUtil.ArraysEqual(pbData, pbModData) &&
!opt.ReadOnly)
{
return(new ProtectedBinary(pb.IsProtected, pbModData));
}
return(null);
}
private static void ReadEntry(XmlNode xmlNode, PwGroup pgParent,
PwDatabase pwStorage)
{
PwEntry pe = new PwEntry(true, true);
pgParent.AddEntry(pe, true);
string strAttachDesc = null, strAttachment = null;
foreach (XmlNode xmlChild in xmlNode)
{
if (xmlChild.Name == ElemTitle)
{
pe.Strings.Set(PwDefs.TitleField, new ProtectedString(
pwStorage.MemoryProtection.ProtectTitle,
XmlUtil.SafeInnerText(xmlChild)));
}
else if (xmlChild.Name == ElemUserName)
{
pe.Strings.Set(PwDefs.UserNameField, new ProtectedString(
pwStorage.MemoryProtection.ProtectUserName,
XmlUtil.SafeInnerText(xmlChild)));
}
else if (xmlChild.Name == ElemUrl)
{
pe.Strings.Set(PwDefs.UrlField, new ProtectedString(
pwStorage.MemoryProtection.ProtectUrl,
XmlUtil.SafeInnerText(xmlChild)));
}
else if (xmlChild.Name == ElemPassword)
{
pe.Strings.Set(PwDefs.PasswordField, new ProtectedString(
pwStorage.MemoryProtection.ProtectPassword,
XmlUtil.SafeInnerText(xmlChild)));
}
else if (xmlChild.Name == ElemNotes)
{
pe.Strings.Set(PwDefs.NotesField, new ProtectedString(
pwStorage.MemoryProtection.ProtectNotes,
FilterSpecial(XmlUtil.SafeInnerXml(xmlChild))));
}
else if (xmlChild.Name == ElemIcon)
{
pe.IconId = ReadIcon(xmlChild, pe.IconId);
}
else if (xmlChild.Name == ElemCreationTime)
{
pe.CreationTime = ParseTime(XmlUtil.SafeInnerText(xmlChild));
}
else if (xmlChild.Name == ElemLastModTime)
{
pe.LastModificationTime = ParseTime(XmlUtil.SafeInnerText(xmlChild));
}
else if (xmlChild.Name == ElemLastAccessTime)
{
pe.LastAccessTime = ParseTime(XmlUtil.SafeInnerText(xmlChild));
}
else if (xmlChild.Name == ElemExpiryTime)
{
string strDate = XmlUtil.SafeInnerText(xmlChild);
pe.Expires = (strDate != ValueNever);
if (pe.Expires)
{
pe.ExpiryTime = ParseTime(strDate);
}
}
else if (xmlChild.Name == ElemAttachDesc)
{
strAttachDesc = XmlUtil.SafeInnerText(xmlChild);
}
else if (xmlChild.Name == ElemAttachment)
{
strAttachment = XmlUtil.SafeInnerText(xmlChild);
}
else
{
Debug.Assert(false);
}
}
if (!string.IsNullOrEmpty(strAttachDesc) && (strAttachment != null))
{
byte[] pbData = Convert.FromBase64String(strAttachment);
ProtectedBinary pb = new ProtectedBinary(false, pbData);
pe.Binaries.Set(strAttachDesc, pb);
}
}
private KdbContext EndXmlElement(KdbContext ctx, XmlReader xr)
{
Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
if ((ctx == KdbContext.KeePassFile) && (xr.Name == ElemDocNode))
{
return(KdbContext.Null);
}
else if ((ctx == KdbContext.Meta) && (xr.Name == ElemMeta))
{
return(KdbContext.KeePassFile);
}
else if ((ctx == KdbContext.Root) && (xr.Name == ElemRoot))
{
return(KdbContext.KeePassFile);
}
else if ((ctx == KdbContext.MemoryProtection) && (xr.Name == ElemMemoryProt))
{
return(KdbContext.Meta);
}
else if ((ctx == KdbContext.CustomIcons) && (xr.Name == ElemCustomIcons))
{
return(KdbContext.Meta);
}
else if ((ctx == KdbContext.CustomIcon) && (xr.Name == ElemCustomIconItem))
{
if ((m_uuidCustomIconID != PwUuid.Zero) && (m_pbCustomIconData != null))
{
m_pwDatabase.CustomIcons.Add(new PwCustomIcon(
m_uuidCustomIconID, m_pbCustomIconData));
m_uuidCustomIconID = PwUuid.Zero;
m_pbCustomIconData = null;
}
else
{
Debug.Assert(false);
}
return(KdbContext.CustomIcons);
}
else if ((ctx == KdbContext.Group) && (xr.Name == ElemGroup))
{
if (PwUuid.Zero.EqualsValue(m_ctxGroup.Uuid))
{
Debug.Assert(false);
m_ctxGroup.Uuid = new PwUuid(true);
}
m_ctxGroups.Pop();
if (m_ctxGroups.Count == 0)
{
m_ctxGroup = null;
return(KdbContext.Root);
}
else
{
m_ctxGroup = m_ctxGroups.Peek();
return(KdbContext.Group);
}
}
else if ((ctx == KdbContext.GroupTimes) && (xr.Name == ElemTimes))
{
return(KdbContext.Group);
}
else if ((ctx == KdbContext.Entry) && (xr.Name == ElemEntry))
{
// Create new UUID if absent
if (PwUuid.Zero.EqualsValue(m_ctxEntry.Uuid))
{
Debug.Assert(false);
m_ctxEntry.Uuid = new PwUuid(true);
}
if (m_bEntryInHistory)
{
m_ctxEntry = m_ctxHistoryBase;
return(KdbContext.EntryHistory);
}
return(KdbContext.Group);
}
else if ((ctx == KdbContext.EntryTimes) && (xr.Name == ElemTimes))
{
return(KdbContext.Entry);
}
else if ((ctx == KdbContext.EntryString) && (xr.Name == ElemString))
{
m_ctxEntry.Strings.Set(m_ctxStringName, m_ctxStringValue);
m_ctxStringName = null;
m_ctxStringValue = null;
return(KdbContext.Entry);
}
else if ((ctx == KdbContext.EntryBinary) && (xr.Name == ElemBinary))
{
m_ctxEntry.Binaries.Set(m_ctxBinaryName, m_ctxBinaryValue);
m_ctxBinaryName = null;
m_ctxBinaryValue = null;
return(KdbContext.Entry);
}
else if ((ctx == KdbContext.EntryAutoType) && (xr.Name == ElemAutoType))
{
return(KdbContext.Entry);
}
else if ((ctx == KdbContext.EntryAutoTypeItem) && (xr.Name == ElemAutoTypeItem))
{
m_ctxEntry.AutoType.Set(m_ctxATName, m_ctxATSeq);
m_ctxATName = null;
m_ctxATSeq = null;
return(KdbContext.EntryAutoType);
}
else if ((ctx == KdbContext.EntryHistory) && (xr.Name == ElemHistory))
{
m_bEntryInHistory = false;
return(KdbContext.Entry);
}
else if ((ctx == KdbContext.RootDeletedObjects) && (xr.Name == ElemDeletedObjects))
{
return(KdbContext.Root);
}
else if ((ctx == KdbContext.DeletedObject) && (xr.Name == ElemDeletedObject))
{
m_ctxDeletedObject = null;
return(KdbContext.RootDeletedObjects);
}
else
{
Debug.Assert(false);
throw new FormatException();
}
}
public static ProtectedBinary Open(string strName, ProtectedBinary pb,
BinaryDataOpenOptions opt)
{
if (string.IsNullOrEmpty(strName))
{
Debug.Assert(false); return(null);
}
if (pb == null)
{
Debug.Assert(false); return(null);
}
if (opt == null)
{
opt = new BinaryDataOpenOptions();
}
byte[] pbData = pb.ReadData();
if (pbData == null)
{
Debug.Assert(false); return(null);
}
BinaryDataHandler h = opt.Handler;
if (h == BinaryDataHandler.Default)
{
h = ChooseHandler(strName, pbData, opt);
}
byte[] pbModData = null;
if (h == BinaryDataHandler.InternalViewer)
{
DataViewerForm dvf = new DataViewerForm();
dvf.InitEx(strName, pbData);
UIUtil.ShowDialogAndDestroy(dvf);
}
else if (h == BinaryDataHandler.InternalEditor)
{
DataEditorForm def = new DataEditorForm();
def.InitEx(strName, pbData);
def.ShowDialog();
if (def.EditedBinaryData != null)
{
pbModData = def.EditedBinaryData;
}
UIUtil.DestroyForm(def);
}
else if (h == BinaryDataHandler.ExternalApp)
{
pbModData = OpenExternal(strName, pbData, opt);
}
else
{
Debug.Assert(false);
}
ProtectedBinary r = null;
if ((pbModData != null) && !MemUtil.ArraysEqual(pbData, pbModData) &&
!opt.ReadOnly)
{
if (FileDialogsEx.CheckAttachmentSize(pbModData.LongLength,
KPRes.AttachFailed + MessageService.NewParagraph + strName))
{
r = new ProtectedBinary(pb.IsProtected, pbModData);
}
}
if (pb.IsProtected)
{
MemUtil.ZeroByteArray(pbData);
}
return(r);
}
public NamedProtectedBinaryBuffer(KeyValuePair <string, ProtectedBinary> namedBinary)
{
Name = namedBinary.Key;
mProtectedBinary = namedBinary.Value;
IsProtected = mProtectedBinary.IsProtected;
}
private bool ReadInnerHeaderField(BinaryReaderEx br)
{
Debug.Assert(br != null);
if (br == null)
{
throw new ArgumentNullException("br");
}
byte btFieldID = br.ReadByte();
int cbSize = MemUtil.BytesToInt32(br.ReadBytes(4));
if (cbSize < 0)
{
throw new FormatException(KLRes.FileCorrupted);
}
byte[] pbData = MemUtil.EmptyByteArray;
if (cbSize > 0)
{
pbData = br.ReadBytes(cbSize);
}
bool bResult = true;
KdbxInnerHeaderFieldID kdbID = (KdbxInnerHeaderFieldID)btFieldID;
switch (kdbID)
{
case KdbxInnerHeaderFieldID.EndOfHeader:
bResult = false; // Returning false indicates end of header
break;
case KdbxInnerHeaderFieldID.InnerRandomStreamID:
SetInnerRandomStreamID(pbData);
break;
case KdbxInnerHeaderFieldID.InnerRandomStreamKey:
Debug.Assert(m_pbInnerRandomStreamKey == null);
m_pbInnerRandomStreamKey = pbData;
CryptoRandom.Instance.AddEntropy(pbData);
break;
case KdbxInnerHeaderFieldID.Binary:
if (pbData.Length < 1)
{
throw new FormatException();
}
KdbxBinaryFlags f = (KdbxBinaryFlags)pbData[0];
bool bProt = ((f & KdbxBinaryFlags.Protected) != KdbxBinaryFlags.None);
ProtectedBinary pb = new ProtectedBinary(bProt, pbData,
1, pbData.Length - 1);
m_pbsBinaries.Add(pb);
if (bProt)
{
MemUtil.ZeroByteArray(pbData);
}
break;
default:
Debug.Assert(false);
break;
}
return(bResult);
}
private static void ReadEntry(XmlNode xmlNode, PwDatabase pwStorage)
{
PwEntry pe = new PwEntry(true, true);
PwGroup pg = pwStorage.RootGroup;
string strAttachDesc = null, strAttachment = null;
foreach (XmlNode xmlChild in xmlNode)
{
if (xmlChild.Name == ElemGroup)
{
string strPreTree = null;
try
{
XmlNode xmlTree = xmlChild.Attributes.GetNamedItem(AttribGroupTree);
strPreTree = xmlTree.Value;
}
catch (Exception) { }
string strLast = XmlUtil.SafeInnerText(xmlChild);
string strGroup = ((!string.IsNullOrEmpty(strPreTree)) ?
strPreTree + "\\" + strLast : strLast);
pg = pwStorage.RootGroup.FindCreateSubTree(strGroup,
new string[1] {
"\\"
}, true);
}
else if (xmlChild.Name == ElemTitle)
{
pe.Strings.Set(PwDefs.TitleField, new ProtectedString(
pwStorage.MemoryProtection.ProtectTitle,
XmlUtil.SafeInnerText(xmlChild)));
}
else if (xmlChild.Name == ElemUserName)
{
pe.Strings.Set(PwDefs.UserNameField, new ProtectedString(
pwStorage.MemoryProtection.ProtectUserName,
XmlUtil.SafeInnerText(xmlChild)));
}
else if (xmlChild.Name == ElemUrl)
{
pe.Strings.Set(PwDefs.UrlField, new ProtectedString(
pwStorage.MemoryProtection.ProtectUrl,
XmlUtil.SafeInnerText(xmlChild)));
}
else if (xmlChild.Name == ElemPassword)
{
pe.Strings.Set(PwDefs.PasswordField, new ProtectedString(
pwStorage.MemoryProtection.ProtectPassword,
XmlUtil.SafeInnerText(xmlChild)));
}
else if (xmlChild.Name == ElemNotes)
{
pe.Strings.Set(PwDefs.NotesField, new ProtectedString(
pwStorage.MemoryProtection.ProtectNotes,
XmlUtil.SafeInnerText(xmlChild)));
}
else if (xmlChild.Name == ElemUuid)
{
pe.SetUuid(new PwUuid(MemUtil.HexStringToByteArray(
XmlUtil.SafeInnerText(xmlChild))), false);
}
else if (xmlChild.Name == ElemImage)
{
int nImage;
if (int.TryParse(XmlUtil.SafeInnerText(xmlChild), out nImage))
{
if ((nImage >= 0) && (nImage < (int)PwIcon.Count))
{
pe.IconId = (PwIcon)nImage;
}
else
{
Debug.Assert(false);
}
}
else
{
Debug.Assert(false);
}
}
else if (xmlChild.Name == ElemCreationTime)
{
pe.CreationTime = ParseTime(XmlUtil.SafeInnerText(xmlChild));
}
else if (xmlChild.Name == ElemLastModTime)
{
pe.LastModificationTime = ParseTime(XmlUtil.SafeInnerText(xmlChild));
}
else if (xmlChild.Name == ElemLastAccessTime)
{
pe.LastAccessTime = ParseTime(XmlUtil.SafeInnerText(xmlChild));
}
else if (xmlChild.Name == ElemExpiryTime)
{
try
{
XmlNode xmlExpires = xmlChild.Attributes.GetNamedItem(AttribExpires);
if (StrUtil.StringToBool(xmlExpires.Value))
{
pe.Expires = true;
pe.ExpiryTime = ParseTime(XmlUtil.SafeInnerText(xmlChild));
}
else
{
Debug.Assert(ParseTime(XmlUtil.SafeInnerText(xmlChild)).Year == 2999);
}
}
catch (Exception) { Debug.Assert(false); }
}
else if (xmlChild.Name == ElemAttachDesc)
{
strAttachDesc = XmlUtil.SafeInnerText(xmlChild);
}
else if (xmlChild.Name == ElemAttachment)
{
strAttachment = XmlUtil.SafeInnerText(xmlChild);
}
else
{
Debug.Assert(false);
}
}
if (!string.IsNullOrEmpty(strAttachDesc) && (strAttachment != null))
{
byte[] pbData = Convert.FromBase64String(strAttachment);
ProtectedBinary pb = new ProtectedBinary(false, pbData);
pe.Binaries.Set(strAttachDesc, pb);
}
pg.AddEntry(pe, true);
}
public KeyData(ProtectedBinary Key)
{
m_pbKeyData = Key;
}
private KdbContext EndXmlElement(KdbContext ctx, XmlReader xr)
{
Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
if ((ctx == KdbContext.KeePassFile) && (xr.Name == ElemDocNode))
{
return(KdbContext.Null);
}
else if ((ctx == KdbContext.Meta) && (xr.Name == ElemMeta))
{
return(KdbContext.KeePassFile);
}
else if ((ctx == KdbContext.Root) && (xr.Name == ElemRoot))
{
return(KdbContext.KeePassFile);
}
else if ((ctx == KdbContext.MemoryProtection) && (xr.Name == ElemMemoryProt))
{
return(KdbContext.Meta);
}
else if ((ctx == KdbContext.CustomIcons) && (xr.Name == ElemCustomIcons))
{
return(KdbContext.Meta);
}
else if ((ctx == KdbContext.CustomIcon) && (xr.Name == ElemCustomIconItem))
{
if (!m_uuidCustomIconID.Equals(PwUuid.Zero) &&
(m_pbCustomIconData != null))
{
m_pwDatabase.CustomIcons.Add(new PwCustomIcon(
m_uuidCustomIconID, m_pbCustomIconData));
}
else
{
Debug.Assert(false);
}
m_uuidCustomIconID = PwUuid.Zero;
m_pbCustomIconData = null;
return(KdbContext.CustomIcons);
}
else if ((ctx == KdbContext.Binaries) && (xr.Name == ElemBinaries))
{
return(KdbContext.Meta);
}
else if ((ctx == KdbContext.CustomData) && (xr.Name == ElemCustomData))
{
return(KdbContext.Meta);
}
else if ((ctx == KdbContext.CustomDataItem) && (xr.Name == ElemStringDictExItem))
{
if ((m_strCustomDataKey != null) && (m_strCustomDataValue != null))
{
m_pwDatabase.CustomData.Set(m_strCustomDataKey, m_strCustomDataValue);
}
else
{
Debug.Assert(false);
}
m_strCustomDataKey = null;
m_strCustomDataValue = null;
return(KdbContext.CustomData);
}
else if ((ctx == KdbContext.Group) && (xr.Name == ElemGroup))
{
if (PwUuid.Zero.Equals(m_ctxGroup.Uuid))
{
m_ctxGroup.Uuid = new PwUuid(true); // No assert (import)
}
m_ctxGroups.Pop();
if (m_ctxGroups.Count == 0)
{
m_ctxGroup = null;
return(KdbContext.Root);
}
else
{
m_ctxGroup = m_ctxGroups.Peek();
return(KdbContext.Group);
}
}
else if ((ctx == KdbContext.GroupTimes) && (xr.Name == ElemTimes))
{
return(KdbContext.Group);
}
else if ((ctx == KdbContext.GroupCustomData) && (xr.Name == ElemCustomData))
{
return(KdbContext.Group);
}
else if ((ctx == KdbContext.GroupCustomDataItem) && (xr.Name == ElemStringDictExItem))
{
if ((m_strGroupCustomDataKey != null) && (m_strGroupCustomDataValue != null))
{
m_ctxGroup.CustomData.Set(m_strGroupCustomDataKey, m_strGroupCustomDataValue);
}
else
{
Debug.Assert(false);
}
m_strGroupCustomDataKey = null;
m_strGroupCustomDataValue = null;
return(KdbContext.GroupCustomData);
}
else if ((ctx == KdbContext.Entry) && (xr.Name == ElemEntry))
{
// Create new UUID if absent
if (PwUuid.Zero.Equals(m_ctxEntry.Uuid))
{
m_ctxEntry.Uuid = new PwUuid(true); // No assert (import)
}
if (m_bEntryInHistory)
{
m_ctxEntry = m_ctxHistoryBase;
return(KdbContext.EntryHistory);
}
return(KdbContext.Group);
}
else if ((ctx == KdbContext.EntryTimes) && (xr.Name == ElemTimes))
{
return(KdbContext.Entry);
}
else if ((ctx == KdbContext.EntryString) && (xr.Name == ElemString))
{
m_ctxEntry.Strings.Set(m_ctxStringName, m_ctxStringValue);
m_ctxStringName = null;
m_ctxStringValue = null;
return(KdbContext.Entry);
}
else if ((ctx == KdbContext.EntryBinary) && (xr.Name == ElemBinary))
{
if (string.IsNullOrEmpty(m_strDetachBins))
{
m_ctxEntry.Binaries.Set(m_ctxBinaryName, m_ctxBinaryValue);
}
else
{
SaveBinary(m_ctxBinaryName, m_ctxBinaryValue, m_strDetachBins);
m_ctxBinaryValue = null;
GC.Collect();
}
m_ctxBinaryName = null;
m_ctxBinaryValue = null;
return(KdbContext.Entry);
}
else if ((ctx == KdbContext.EntryAutoType) && (xr.Name == ElemAutoType))
{
return(KdbContext.Entry);
}
else if ((ctx == KdbContext.EntryAutoTypeItem) && (xr.Name == ElemAutoTypeItem))
{
AutoTypeAssociation atAssoc = new AutoTypeAssociation(m_ctxATName,
m_ctxATSeq);
m_ctxEntry.AutoType.Add(atAssoc);
m_ctxATName = null;
m_ctxATSeq = null;
return(KdbContext.EntryAutoType);
}
else if ((ctx == KdbContext.EntryCustomData) && (xr.Name == ElemCustomData))
{
return(KdbContext.Entry);
}
else if ((ctx == KdbContext.EntryCustomDataItem) && (xr.Name == ElemStringDictExItem))
{
if ((m_strEntryCustomDataKey != null) && (m_strEntryCustomDataValue != null))
{
m_ctxEntry.CustomData.Set(m_strEntryCustomDataKey, m_strEntryCustomDataValue);
}
else
{
Debug.Assert(false);
}
m_strEntryCustomDataKey = null;
m_strEntryCustomDataValue = null;
return(KdbContext.EntryCustomData);
}
else if ((ctx == KdbContext.EntryHistory) && (xr.Name == ElemHistory))
{
m_bEntryInHistory = false;
return(KdbContext.Entry);
}
else if ((ctx == KdbContext.RootDeletedObjects) && (xr.Name == ElemDeletedObjects))
{
return(KdbContext.Root);
}
else if ((ctx == KdbContext.DeletedObject) && (xr.Name == ElemDeletedObject))
{
m_ctxDeletedObject = null;
return(KdbContext.RootDeletedObjects);
}
else
{
Debug.Assert(false);
throw new FormatException();
}
}
private ProtectedBinary ReadProtectedBinary(XmlReader xr)
{
if (xr.MoveToAttribute(AttrRef))
{
string strRef = xr.Value;
if (!string.IsNullOrEmpty(strRef))
{
int iRef;
if (StrUtil.TryParseIntInvariant(strRef, out iRef))
{
ProtectedBinary pb = m_pbsBinaries.Get(iRef);
if (pb != null)
{
// https://sourceforge.net/p/keepass/feature-requests/2023/
xr.MoveToElement();
#if DEBUG
string strInner = ReadStringRaw(xr);
Debug.Assert(string.IsNullOrEmpty(strInner));
#else
ReadStringRaw(xr);
#endif
return(pb);
}
else
{
Debug.Assert(false);
}
}
else
{
Debug.Assert(false);
}
}
else
{
Debug.Assert(false);
}
}
bool bCompressed = false;
if (xr.MoveToAttribute(AttrCompressed))
{
bCompressed = (xr.Value == ValTrue);
}
XorredBuffer xb = ProcessNode(xr);
if (xb != null)
{
Debug.Assert(!bCompressed); // See SubWriteValue(ProtectedBinary value)
try { return(new ProtectedBinary(true, xb)); }
finally { xb.Dispose(); }
}
byte[] pbData = ReadBase64(xr, true);
if (pbData.Length == 0)
{
return(new ProtectedBinary());
}
if (bCompressed)
{
pbData = MemUtil.Decompress(pbData);
}
return(new ProtectedBinary(false, pbData));
}
// Copied from PwEntryForm.BinImportFiles (PwEntryForm.cs), as the functionality isn't otherwise exposed.
private void BinImportFiles(string[] vPaths)
{
var m_vBinaries = Entry.Binaries; // Allow copied code to refer directly to entry binaries
if (vPaths == null)
{
Debug.Assert(false); return;
}
//UpdateEntryBinaries(true, false);
foreach (string strFile in vPaths)
{
if (string.IsNullOrEmpty(strFile))
{
Debug.Assert(false); continue;
}
byte[] vBytes = null;
string strMsg, strItem = UrlUtil.GetFileName(strFile);
if (m_vBinaries.Get(strItem) != null)
{
strMsg = KPRes.AttachedExistsAlready + MessageService.NewLine +
strItem + MessageService.NewParagraph + KPRes.AttachNewRename +
MessageService.NewParagraph + KPRes.AttachNewRenameRemarks0 +
MessageService.NewLine + KPRes.AttachNewRenameRemarks1 +
MessageService.NewLine + KPRes.AttachNewRenameRemarks2;
DialogResult dr = MessageService.Ask(strMsg, null,
MessageBoxButtons.YesNoCancel);
if (dr == DialogResult.Cancel)
{
continue;
}
else if (dr == DialogResult.Yes)
{
string strFileName = UrlUtil.StripExtension(strItem);
string strExtension = "." + UrlUtil.GetExtension(strItem);
int nTry = 0;
while (true)
{
string strNewName = strFileName + nTry.ToString() + strExtension;
if (m_vBinaries.Get(strNewName) == null)
{
strItem = strNewName;
break;
}
++nTry;
}
}
}
try
{
vBytes = File.ReadAllBytes(strFile);
//vBytes = DataEditorForm.ConvertAttachment(strItem, vBytes);
vBytes = ConvertAttachment(strItem, vBytes);
if (vBytes != null)
{
ProtectedBinary pb = new ProtectedBinary(false, vBytes);
m_vBinaries.Set(strItem, pb);
}
}
catch (Exception exAttach)
{
MessageService.ShowWarning(KPRes.AttachFailed, strFile, exAttach);
}
}
//UpdateEntryBinaries(false, true);
//ResizeColumnHeaders();
}
private KdbContext ReadXmlElement(KdbContext ctx, XmlReader xr)
{
Debug.Assert(xr.NodeType == XmlNodeType.Element);
switch (ctx)
{
case KdbContext.Null:
if (xr.Name == ElemDocNode)
{
return(SwitchContext(ctx, KdbContext.KeePassFile, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.KeePassFile:
if (xr.Name == ElemMeta)
{
return(SwitchContext(ctx, KdbContext.Meta, xr));
}
else if (xr.Name == ElemRoot)
{
return(SwitchContext(ctx, KdbContext.Root, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.Meta:
if (xr.Name == ElemGenerator)
{
ReadString(xr); // Ignore
}
else if (xr.Name == ElemHeaderHash)
{
string strHash = ReadString(xr);
if (!string.IsNullOrEmpty(strHash) && (m_pbHashOfHeader != null) &&
!m_bRepairMode)
{
byte[] pbHash = Convert.FromBase64String(strHash);
if (!MemUtil.ArraysEqual(pbHash, m_pbHashOfHeader))
{
throw new IOException(KLRes.FileCorrupted);
}
}
}
else if (xr.Name == ElemDbName)
{
m_pwDatabase.Name = ReadString(xr);
}
else if (xr.Name == ElemDbNameChanged)
{
m_pwDatabase.NameChanged = ReadTime(xr);
}
else if (xr.Name == ElemDbDesc)
{
m_pwDatabase.Description = ReadString(xr);
}
else if (xr.Name == ElemDbDescChanged)
{
m_pwDatabase.DescriptionChanged = ReadTime(xr);
}
else if (xr.Name == ElemDbDefaultUser)
{
m_pwDatabase.DefaultUserName = ReadString(xr);
}
else if (xr.Name == ElemDbDefaultUserChanged)
{
m_pwDatabase.DefaultUserNameChanged = ReadTime(xr);
}
else if (xr.Name == ElemDbMntncHistoryDays)
{
m_pwDatabase.MaintenanceHistoryDays = ReadUInt(xr, 365);
}
else if (xr.Name == ElemDbColor)
{
string strColor = ReadString(xr);
if (!string.IsNullOrEmpty(strColor))
{
m_pwDatabase.Color = ColorTranslator.FromHtml(strColor);
}
}
else if (xr.Name == ElemDbKeyChanged)
{
m_pwDatabase.MasterKeyChanged = ReadTime(xr);
}
else if (xr.Name == ElemDbKeyChangeRec)
{
m_pwDatabase.MasterKeyChangeRec = ReadLong(xr, -1);
}
else if (xr.Name == ElemDbKeyChangeForce)
{
m_pwDatabase.MasterKeyChangeForce = ReadLong(xr, -1);
}
else if (xr.Name == ElemMemoryProt)
{
return(SwitchContext(ctx, KdbContext.MemoryProtection, xr));
}
else if (xr.Name == ElemCustomIcons)
{
return(SwitchContext(ctx, KdbContext.CustomIcons, xr));
}
else if (xr.Name == ElemRecycleBinEnabled)
{
m_pwDatabase.RecycleBinEnabled = ReadBool(xr, true);
}
else if (xr.Name == ElemRecycleBinUuid)
{
m_pwDatabase.RecycleBinUuid = ReadUuid(xr);
}
else if (xr.Name == ElemRecycleBinChanged)
{
m_pwDatabase.RecycleBinChanged = ReadTime(xr);
}
else if (xr.Name == ElemEntryTemplatesGroup)
{
m_pwDatabase.EntryTemplatesGroup = ReadUuid(xr);
}
else if (xr.Name == ElemEntryTemplatesGroupChanged)
{
m_pwDatabase.EntryTemplatesGroupChanged = ReadTime(xr);
}
else if (xr.Name == ElemHistoryMaxItems)
{
m_pwDatabase.HistoryMaxItems = ReadInt(xr, -1);
}
else if (xr.Name == ElemHistoryMaxSize)
{
m_pwDatabase.HistoryMaxSize = ReadLong(xr, -1);
}
else if (xr.Name == ElemLastSelectedGroup)
{
m_pwDatabase.LastSelectedGroup = ReadUuid(xr);
}
else if (xr.Name == ElemLastTopVisibleGroup)
{
m_pwDatabase.LastTopVisibleGroup = ReadUuid(xr);
}
else if (xr.Name == ElemBinaries)
{
return(SwitchContext(ctx, KdbContext.Binaries, xr));
}
else if (xr.Name == ElemCustomData)
{
return(SwitchContext(ctx, KdbContext.CustomData, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.MemoryProtection:
if (xr.Name == ElemProtTitle)
{
m_pwDatabase.MemoryProtection.ProtectTitle = ReadBool(xr, false);
}
else if (xr.Name == ElemProtUserName)
{
m_pwDatabase.MemoryProtection.ProtectUserName = ReadBool(xr, false);
}
else if (xr.Name == ElemProtPassword)
{
m_pwDatabase.MemoryProtection.ProtectPassword = ReadBool(xr, true);
}
else if (xr.Name == ElemProtUrl)
{
m_pwDatabase.MemoryProtection.ProtectUrl = ReadBool(xr, false);
}
else if (xr.Name == ElemProtNotes)
{
m_pwDatabase.MemoryProtection.ProtectNotes = ReadBool(xr, false);
}
// else if(xr.Name == ElemProtAutoHide)
// m_pwDatabase.MemoryProtection.AutoEnableVisualHiding = ReadBool(xr, true);
else
{
ReadUnknown(xr);
}
break;
case KdbContext.CustomIcons:
if (xr.Name == ElemCustomIconItem)
{
return(SwitchContext(ctx, KdbContext.CustomIcon, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.CustomIcon:
if (xr.Name == ElemCustomIconItemID)
{
m_uuidCustomIconID = ReadUuid(xr);
}
else if (xr.Name == ElemCustomIconItemData)
{
string strData = ReadString(xr);
if (!string.IsNullOrEmpty(strData))
{
m_pbCustomIconData = Convert.FromBase64String(strData);
}
else
{
Debug.Assert(false);
}
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.Binaries:
if (xr.Name == ElemBinary)
{
if (xr.MoveToAttribute(AttrId))
{
string strKey = xr.Value;
ProtectedBinary pbData = ReadProtectedBinary(xr);
m_dictBinPool[strKey ?? string.Empty] = pbData;
}
else
{
ReadUnknown(xr);
}
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.CustomData:
if (xr.Name == ElemStringDictExItem)
{
return(SwitchContext(ctx, KdbContext.CustomDataItem, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.CustomDataItem:
if (xr.Name == ElemKey)
{
m_strCustomDataKey = ReadString(xr);
}
else if (xr.Name == ElemValue)
{
m_strCustomDataValue = ReadString(xr);
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.Root:
if (xr.Name == ElemGroup)
{
Debug.Assert(m_ctxGroups.Count == 0);
if (m_ctxGroups.Count != 0)
{
throw new FormatException();
}
m_pwDatabase.RootGroup = new PwGroup(false, false);
m_ctxGroups.Push(m_pwDatabase.RootGroup);
m_ctxGroup = m_ctxGroups.Peek();
return(SwitchContext(ctx, KdbContext.Group, xr));
}
else if (xr.Name == ElemDeletedObjects)
{
return(SwitchContext(ctx, KdbContext.RootDeletedObjects, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.Group:
if (xr.Name == ElemUuid)
{
m_ctxGroup.Uuid = ReadUuid(xr);
}
else if (xr.Name == ElemName)
{
m_ctxGroup.Name = ReadString(xr);
}
else if (xr.Name == ElemNotes)
{
m_ctxGroup.Notes = ReadString(xr);
}
else if (xr.Name == ElemIcon)
{
m_ctxGroup.IconId = (PwIcon)ReadInt(xr, (int)PwIcon.Folder);
}
else if (xr.Name == ElemCustomIconID)
{
m_ctxGroup.CustomIconUuid = ReadUuid(xr);
}
else if (xr.Name == ElemTimes)
{
return(SwitchContext(ctx, KdbContext.GroupTimes, xr));
}
else if (xr.Name == ElemIsExpanded)
{
m_ctxGroup.IsExpanded = ReadBool(xr, true);
}
else if (xr.Name == ElemGroupDefaultAutoTypeSeq)
{
m_ctxGroup.DefaultAutoTypeSequence = ReadString(xr);
}
else if (xr.Name == ElemEnableAutoType)
{
m_ctxGroup.EnableAutoType = StrUtil.StringToBoolEx(ReadString(xr));
}
else if (xr.Name == ElemEnableSearching)
{
m_ctxGroup.EnableSearching = StrUtil.StringToBoolEx(ReadString(xr));
}
else if (xr.Name == ElemLastTopVisibleEntry)
{
m_ctxGroup.LastTopVisibleEntry = ReadUuid(xr);
}
else if (xr.Name == ElemGroup)
{
m_ctxGroup = new PwGroup(false, false);
m_ctxGroups.Peek().AddGroup(m_ctxGroup, true);
m_ctxGroups.Push(m_ctxGroup);
return(SwitchContext(ctx, KdbContext.Group, xr));
}
else if (xr.Name == ElemEntry)
{
m_ctxEntry = new PwEntry(false, false);
m_ctxGroup.AddEntry(m_ctxEntry, true);
m_bEntryInHistory = false;
return(SwitchContext(ctx, KdbContext.Entry, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.Entry:
if (xr.Name == ElemUuid)
{
m_ctxEntry.Uuid = ReadUuid(xr);
}
else if (xr.Name == ElemIcon)
{
m_ctxEntry.IconId = (PwIcon)ReadInt(xr, (int)PwIcon.Key);
}
else if (xr.Name == ElemCustomIconID)
{
m_ctxEntry.CustomIconUuid = ReadUuid(xr);
}
else if (xr.Name == ElemFgColor)
{
string strColor = ReadString(xr);
if (!string.IsNullOrEmpty(strColor))
{
m_ctxEntry.ForegroundColor = ColorTranslator.FromHtml(strColor);
}
}
else if (xr.Name == ElemBgColor)
{
string strColor = ReadString(xr);
if (!string.IsNullOrEmpty(strColor))
{
m_ctxEntry.BackgroundColor = ColorTranslator.FromHtml(strColor);
}
}
else if (xr.Name == ElemOverrideUrl)
{
m_ctxEntry.OverrideUrl = ReadString(xr);
}
else if (xr.Name == ElemTags)
{
m_ctxEntry.Tags = StrUtil.StringToTags(ReadString(xr));
}
else if (xr.Name == ElemTimes)
{
return(SwitchContext(ctx, KdbContext.EntryTimes, xr));
}
else if (xr.Name == ElemString)
{
return(SwitchContext(ctx, KdbContext.EntryString, xr));
}
else if (xr.Name == ElemBinary)
{
return(SwitchContext(ctx, KdbContext.EntryBinary, xr));
}
else if (xr.Name == ElemAutoType)
{
return(SwitchContext(ctx, KdbContext.EntryAutoType, xr));
}
else if (xr.Name == ElemHistory)
{
Debug.Assert(m_bEntryInHistory == false);
if (m_bEntryInHistory == false)
{
m_ctxHistoryBase = m_ctxEntry;
return(SwitchContext(ctx, KdbContext.EntryHistory, xr));
}
else
{
ReadUnknown(xr);
}
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.GroupTimes:
case KdbContext.EntryTimes:
ITimeLogger tl = ((ctx == KdbContext.GroupTimes) ?
(ITimeLogger)m_ctxGroup : (ITimeLogger)m_ctxEntry);
Debug.Assert(tl != null);
if (xr.Name == ElemCreationTime)
{
tl.CreationTime = ReadTime(xr);
}
else if (xr.Name == ElemLastModTime)
{
tl.LastModificationTime = ReadTime(xr);
}
else if (xr.Name == ElemLastAccessTime)
{
tl.LastAccessTime = ReadTime(xr);
}
else if (xr.Name == ElemExpiryTime)
{
tl.ExpiryTime = ReadTime(xr);
}
else if (xr.Name == ElemExpires)
{
tl.Expires = ReadBool(xr, false);
}
else if (xr.Name == ElemUsageCount)
{
tl.UsageCount = ReadULong(xr, 0);
}
else if (xr.Name == ElemLocationChanged)
{
tl.LocationChanged = ReadTime(xr);
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.EntryString:
if (xr.Name == ElemKey)
{
m_ctxStringName = ReadString(xr);
}
else if (xr.Name == ElemValue)
{
m_ctxStringValue = ReadProtectedString(xr);
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.EntryBinary:
if (xr.Name == ElemKey)
{
m_ctxBinaryName = ReadString(xr);
}
else if (xr.Name == ElemValue)
{
m_ctxBinaryValue = ReadProtectedBinary(xr);
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.EntryAutoType:
if (xr.Name == ElemAutoTypeEnabled)
{
m_ctxEntry.AutoType.Enabled = ReadBool(xr, true);
}
else if (xr.Name == ElemAutoTypeObfuscation)
{
m_ctxEntry.AutoType.ObfuscationOptions =
(AutoTypeObfuscationOptions)ReadInt(xr, 0);
}
else if (xr.Name == ElemAutoTypeDefaultSeq)
{
m_ctxEntry.AutoType.DefaultSequence = ReadString(xr);
}
else if (xr.Name == ElemAutoTypeItem)
{
return(SwitchContext(ctx, KdbContext.EntryAutoTypeItem, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.EntryAutoTypeItem:
if (xr.Name == ElemWindow)
{
m_ctxATName = ReadString(xr);
}
else if (xr.Name == ElemKeystrokeSequence)
{
m_ctxATSeq = ReadString(xr);
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.EntryHistory:
if (xr.Name == ElemEntry)
{
m_ctxEntry = new PwEntry(false, false);
m_ctxHistoryBase.History.Add(m_ctxEntry);
m_bEntryInHistory = true;
return(SwitchContext(ctx, KdbContext.Entry, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.RootDeletedObjects:
if (xr.Name == ElemDeletedObject)
{
m_ctxDeletedObject = new PwDeletedObject();
m_pwDatabase.DeletedObjects.Add(m_ctxDeletedObject);
return(SwitchContext(ctx, KdbContext.DeletedObject, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.DeletedObject:
if (xr.Name == ElemUuid)
{
m_ctxDeletedObject.Uuid = ReadUuid(xr);
}
else if (xr.Name == ElemDeletionTime)
{
m_ctxDeletedObject.DeletionTime = ReadTime(xr);
}
else
{
ReadUnknown(xr);
}
break;
default:
ReadUnknown(xr);
break;
}
return(ctx);
}
private VirtualFileDataObject.FileDescriptor CreateFileDescriptor(string name, ProtectedBinary binary)
{
var descriptor = new VirtualFileDataObject.FileDescriptor();
descriptor.Name = "\\" + name;
descriptor.Length = binary.Length;
descriptor.StreamContents = stream =>
{
var data = binary.ReadData();
stream.Write(data, 0, data.Length);
};
return(descriptor);
}
private KdbContext ReadXmlElement(KdbContext ctx, XmlReader xr)
{
Debug.Assert(xr.NodeType == XmlNodeType.Element);
switch (ctx)
{
case KdbContext.Null:
if (xr.Name == ElemDocNode)
{
return(SwitchContext(ctx, KdbContext.KeePassFile, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.KeePassFile:
if (xr.Name == ElemMeta)
{
return(SwitchContext(ctx, KdbContext.Meta, xr));
}
else if (xr.Name == ElemRoot)
{
return(SwitchContext(ctx, KdbContext.Root, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.Meta:
if (xr.Name == ElemGenerator)
{
ReadString(xr); // Ignore
}
else if (xr.Name == ElemDbName)
{
m_pwDatabase.Name = ReadString(xr);
}
else if (xr.Name == ElemDbDesc)
{
m_pwDatabase.Description = ReadString(xr);
}
else if (xr.Name == ElemDbDefaultUser)
{
m_pwDatabase.DefaultUserName = ReadString(xr);
}
else if (xr.Name == ElemDbMntncHistoryDays)
{
m_pwDatabase.MaintenanceHistoryDays = ReadUInt(xr, 365);
}
else if (xr.Name == ElemMemoryProt)
{
return(SwitchContext(ctx, KdbContext.MemoryProtection, xr));
}
else if (xr.Name == ElemCustomIcons)
{
return(SwitchContext(ctx, KdbContext.CustomIcons, xr));
}
else if (xr.Name == ElemLastSelectedGroup)
{
m_pwDatabase.LastSelectedGroup = ReadUuid(xr);
}
else if (xr.Name == ElemLastTopVisibleGroup)
{
m_pwDatabase.LastTopVisibleGroup = ReadUuid(xr);
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.MemoryProtection:
if (xr.Name == ElemProtTitle)
{
m_pwDatabase.MemoryProtection.ProtectNotes = ReadBool(xr, false);
}
else if (xr.Name == ElemProtUserName)
{
m_pwDatabase.MemoryProtection.ProtectUserName = ReadBool(xr, false);
}
else if (xr.Name == ElemProtPassword)
{
m_pwDatabase.MemoryProtection.ProtectPassword = ReadBool(xr, true);
}
else if (xr.Name == ElemProtURL)
{
m_pwDatabase.MemoryProtection.ProtectUrl = ReadBool(xr, false);
}
else if (xr.Name == ElemProtNotes)
{
m_pwDatabase.MemoryProtection.ProtectNotes = ReadBool(xr, false);
}
else if (xr.Name == ElemProtAutoHide)
{
m_pwDatabase.MemoryProtection.AutoEnableVisualHiding = ReadBool(xr, true);
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.CustomIcons:
if (xr.Name == ElemCustomIconItem)
{
return(SwitchContext(ctx, KdbContext.CustomIcon, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.CustomIcon:
if (xr.Name == ElemCustomIconItemID)
{
m_uuidCustomIconID = ReadUuid(xr);
}
else if (xr.Name == ElemCustomIconItemData)
{
string strData = ReadString(xr);
if ((strData != null) && (strData.Length > 0))
{
m_pbCustomIconData = Convert.FromBase64String(strData);
}
else
{
Debug.Assert(false);
}
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.Root:
if (xr.Name == ElemGroup)
{
Debug.Assert(m_ctxGroups.Count == 0);
if (m_ctxGroups.Count != 0)
{
throw new FormatException();
}
m_pwDatabase.RootGroup = new PwGroup(false, false);
m_ctxGroups.Push(m_pwDatabase.RootGroup);
m_ctxGroup = m_ctxGroups.Peek();
return(SwitchContext(ctx, KdbContext.Group, xr));
}
else if (xr.Name == ElemDeletedObjects)
{
return(SwitchContext(ctx, KdbContext.RootDeletedObjects, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.Group:
if (xr.Name == ElemUuid)
{
m_ctxGroup.Uuid = ReadUuid(xr);
}
else if (xr.Name == ElemName)
{
m_ctxGroup.Name = ReadString(xr);
}
else if (xr.Name == ElemNotes)
{
m_ctxGroup.Notes = ReadString(xr);
}
else if (xr.Name == ElemIcon)
{
m_ctxGroup.IconId = (PwIcon)ReadUInt(xr, (uint)PwIcon.Folder);
}
else if (xr.Name == ElemCustomIconID)
{
m_ctxGroup.CustomIconUuid = ReadUuid(xr);
}
else if (xr.Name == ElemTimes)
{
return(SwitchContext(ctx, KdbContext.GroupTimes, xr));
}
else if (xr.Name == ElemIsExpanded)
{
m_ctxGroup.IsExpanded = ReadBool(xr, true);
}
else if (xr.Name == ElemGroupDefaultAutoTypeSeq)
{
m_ctxGroup.DefaultAutoTypeSequence = ReadString(xr);
}
else if (xr.Name == ElemLastTopVisibleEntry)
{
m_ctxGroup.LastTopVisibleEntry = ReadUuid(xr);
}
else if (xr.Name == ElemGroup)
{
m_ctxGroup = new PwGroup(false, false);
m_ctxGroups.Peek().AddGroup(m_ctxGroup, true);
m_ctxGroups.Push(m_ctxGroup);
return(SwitchContext(ctx, KdbContext.Group, xr));
}
else if (xr.Name == ElemEntry)
{
m_ctxEntry = new PwEntry(false, false);
m_ctxGroup.AddEntry(m_ctxEntry, true);
m_bEntryInHistory = false;
return(SwitchContext(ctx, KdbContext.Entry, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.Entry:
if (xr.Name == ElemUuid)
{
m_ctxEntry.Uuid = ReadUuid(xr);
}
else if (xr.Name == ElemIcon)
{
m_ctxEntry.IconId = (PwIcon)ReadUInt(xr, (uint)PwIcon.Key);
}
else if (xr.Name == ElemCustomIconID)
{
m_ctxEntry.CustomIconUuid = ReadUuid(xr);
}
else if (xr.Name == ElemFgColor)
{
string strColor = ReadString(xr);
if ((strColor != null) && (strColor.Length > 0))
{
m_ctxEntry.ForegroundColor = ColorTranslator.FromHtml(strColor);
}
}
else if (xr.Name == ElemBgColor)
{
string strColor = ReadString(xr);
if ((strColor != null) && (strColor.Length > 0))
{
m_ctxEntry.BackgroundColor = ColorTranslator.FromHtml(strColor);
}
}
else if (xr.Name == ElemOverrideUrl)
{
m_ctxEntry.OverrideUrl = ReadString(xr);
}
else if (xr.Name == ElemTimes)
{
return(SwitchContext(ctx, KdbContext.EntryTimes, xr));
}
else if (xr.Name == ElemString)
{
return(SwitchContext(ctx, KdbContext.EntryString, xr));
}
else if (xr.Name == ElemBinary)
{
return(SwitchContext(ctx, KdbContext.EntryBinary, xr));
}
else if (xr.Name == ElemAutoType)
{
return(SwitchContext(ctx, KdbContext.EntryAutoType, xr));
}
else if (xr.Name == ElemHistory)
{
Debug.Assert(m_bEntryInHistory == false);
if (m_bEntryInHistory == false)
{
m_ctxHistoryBase = m_ctxEntry;
return(SwitchContext(ctx, KdbContext.EntryHistory, xr));
}
else
{
ReadUnknown(xr);
}
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.GroupTimes:
case KdbContext.EntryTimes:
ITimeLogger tl = ((ctx == KdbContext.GroupTimes) ?
(ITimeLogger)m_ctxGroup : (ITimeLogger)m_ctxEntry);
Debug.Assert(tl != null);
if (xr.Name == ElemLastModTime)
{
tl.LastModificationTime = ReadTime(xr);
}
else if (xr.Name == ElemCreationTime)
{
tl.CreationTime = ReadTime(xr);
}
else if (xr.Name == ElemLastAccessTime)
{
tl.LastAccessTime = ReadTime(xr);
}
else if (xr.Name == ElemExpiryTime)
{
tl.ExpiryTime = ReadTime(xr);
}
else if (xr.Name == ElemExpires)
{
tl.Expires = ReadBool(xr, false);
}
else if (xr.Name == ElemUsageCount)
{
tl.UsageCount = ReadULong(xr, 0);
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.EntryString:
if (xr.Name == ElemKey)
{
m_ctxStringName = ReadString(xr);
}
else if (xr.Name == ElemValue)
{
m_ctxStringValue = ReadProtectedString(xr);
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.EntryBinary:
if (xr.Name == ElemKey)
{
m_ctxBinaryName = ReadString(xr);
}
else if (xr.Name == ElemValue)
{
m_ctxBinaryValue = ReadProtectedBinary(xr);
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.EntryAutoType:
if (xr.Name == ElemAutoTypeEnabled)
{
m_ctxEntry.AutoType.Enabled = ReadBool(xr, true);
}
else if (xr.Name == ElemAutoTypeObfuscation)
{
m_ctxEntry.AutoType.ObfuscationOptions =
(AutoTypeObfuscationOptions)ReadUInt(xr, 0);
}
else if (xr.Name == ElemAutoTypeDefaultSeq)
{
m_ctxEntry.AutoType.DefaultSequence = ReadString(xr);
}
else if (xr.Name == ElemAutoTypeItem)
{
return(SwitchContext(ctx, KdbContext.EntryAutoTypeItem, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.EntryAutoTypeItem:
if (xr.Name == ElemWindow)
{
m_ctxATName = ReadString(xr);
}
else if (xr.Name == ElemKeystrokeSequence)
{
m_ctxATSeq = ReadString(xr);
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.EntryHistory:
if (xr.Name == ElemEntry)
{
m_ctxEntry = new PwEntry(false, false);
m_ctxHistoryBase.History.Add(m_ctxEntry);
m_bEntryInHistory = true;
return(SwitchContext(ctx, KdbContext.Entry, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.RootDeletedObjects:
if (xr.Name == ElemDeletedObject)
{
m_ctxDeletedObject = new PwDeletedObject();
m_pwDatabase.DeletedObjects.Add(m_ctxDeletedObject);
return(SwitchContext(ctx, KdbContext.DeletedObject, xr));
}
else
{
ReadUnknown(xr);
}
break;
case KdbContext.DeletedObject:
if (xr.Name == ElemUuid)
{
m_ctxDeletedObject.Uuid = ReadUuid(xr);
}
else if (xr.Name == ElemDeletionTime)
{
m_ctxDeletedObject.DeletionTime = ReadTime(xr);
}
else
{
ReadUnknown(xr);
}
break;
default:
ReadUnknown(xr);
break;
}
return(ctx);
}
public KcpData(KcpType kcpType, ProtectedBinary encryptedData = null, string name = null)
{
KcpType = kcpType;
EncryptedData = encryptedData;
CustomName = name;
}
private static void TestProtectedObjects()
{
#if DEBUG
Encoding enc = StrUtil.Utf8;
byte[] pbData = enc.GetBytes("Test Test Test Test");
ProtectedBinary pb = new ProtectedBinary(true, pbData);
if (!pb.IsProtected)
{
throw new SecurityException("ProtectedBinary-1");
}
byte[] pbDec = pb.ReadData();
if (!MemUtil.ArraysEqual(pbData, pbDec))
{
throw new SecurityException("ProtectedBinary-2");
}
if (!pb.IsProtected)
{
throw new SecurityException("ProtectedBinary-3");
}
byte[] pbData2 = enc.GetBytes("Test Test Test Test");
byte[] pbData3 = enc.GetBytes("Test Test Test Test Test");
ProtectedBinary pb2 = new ProtectedBinary(true, pbData2);
ProtectedBinary pb3 = new ProtectedBinary(true, pbData3);
if (!pb.Equals(pb2))
{
throw new SecurityException("ProtectedBinary-4");
}
if (pb.Equals(pb3))
{
throw new SecurityException("ProtectedBinary-5");
}
if (pb2.Equals(pb3))
{
throw new SecurityException("ProtectedBinary-6");
}
if (pb.GetHashCode() != pb2.GetHashCode())
{
throw new SecurityException("ProtectedBinary-7");
}
if (!((object)pb).Equals((object)pb2))
{
throw new SecurityException("ProtectedBinary-8");
}
if (((object)pb).Equals((object)pb3))
{
throw new SecurityException("ProtectedBinary-9");
}
if (((object)pb2).Equals((object)pb3))
{
throw new SecurityException("ProtectedBinary-10");
}
ProtectedString ps = new ProtectedString();
if (ps.Length != 0)
{
throw new SecurityException("ProtectedString-1");
}
if (!ps.IsEmpty)
{
throw new SecurityException("ProtectedString-2");
}
if (ps.ReadString().Length != 0)
{
throw new SecurityException("ProtectedString-3");
}
ps = new ProtectedString(true, "Test");
ProtectedString ps2 = new ProtectedString(true, enc.GetBytes("Test"));
if (ps.IsEmpty)
{
throw new SecurityException("ProtectedString-4");
}
pbData = ps.ReadUtf8();
pbData2 = ps2.ReadUtf8();
if (!MemUtil.ArraysEqual(pbData, pbData2))
{
throw new SecurityException("ProtectedString-5");
}
if (pbData.Length != 4)
{
throw new SecurityException("ProtectedString-6");
}
if (ps.ReadString() != ps2.ReadString())
{
throw new SecurityException("ProtectedString-7");
}
pbData = ps.ReadUtf8();
pbData2 = ps2.ReadUtf8();
if (!MemUtil.ArraysEqual(pbData, pbData2))
{
throw new SecurityException("ProtectedString-8");
}
if (!ps.IsProtected)
{
throw new SecurityException("ProtectedString-9");
}
if (!ps2.IsProtected)
{
throw new SecurityException("ProtectedString-10");
}
Random r = new Random();
string str = string.Empty;
ps = new ProtectedString();
for (int i = 0; i < 100; ++i)
{
bool bProt = ((r.Next() % 4) != 0);
ps = ps.WithProtection(bProt);
int x = r.Next(str.Length + 1);
int c = r.Next(20);
char ch = (char)r.Next(1, 256);
string strIns = new string(ch, c);
str = str.Insert(x, strIns);
ps = ps.Insert(x, strIns);
if (ps.IsProtected != bProt)
{
throw new SecurityException("ProtectedString-11");
}
if (ps.ReadString() != str)
{
throw new SecurityException("ProtectedString-12");
}
ps = ps.WithProtection(bProt);
x = r.Next(str.Length);
c = r.Next(str.Length - x + 1);
str = str.Remove(x, c);
ps = ps.Remove(x, c);
if (ps.IsProtected != bProt)
{
throw new SecurityException("ProtectedString-13");
}
if (ps.ReadString() != str)
{
throw new SecurityException("ProtectedString-14");
}
}
#endif
}
