public void Deserialize(XElement input, AXMLSerializationSettings opt)
{
if (input.Name.LocalName != "config")
{
throw new Exception("LocalName != 'config'");
}
Name = XHelper.GetChildValue(input, "Name", "headless");
}
private XElement SerializeRemoteStorageAccount(RemoteStorageAccount rsa, AXMLSerializationSettings opt)
{
var x = CreateXElem("Account", SettingObjectTypeEnum.RemoteStorageAccount, null, opt);
x.Add(CreateXElem("ID", SettingObjectTypeEnum.Guid, rsa.ID.ToString("B"), opt));
x.Add(CreateXElem("Plugin", SettingObjectTypeEnum.Guid, rsa.Plugin.GetUniqueID().ToString("B"), opt));
x.Add(CreateXElem("Config", "Generic", rsa.Config.Serialize(opt), opt));
return(x);
}
private RemoteStorageAccount DeserializeRemoteStorageAccount(XElement e, AXMLSerializationSettings opt)
{
var rsa = new RemoteStorageAccount();
rsa.ID = XHelper.GetChildValue(e, "ID", Guid.Empty);
rsa.Plugin = PluginManagerSingleton.Inst.GetPlugin(XHelper.GetChildValue(e, "Plugin", Guid.Empty));
rsa.Config = rsa.Plugin.CreateEmptyRemoteStorageConfiguration();
rsa.Config.Deserialize(XHelper.GetChildOrThrow(e, "Config").Elements().Single(), opt);
return(rsa);
}
private XElement CreateXElem(string name, object type, object content, AXMLSerializationSettings opt)
{
var r = content != null ? new XElement(name, content) : new XElement(name);
if (type != null && (opt & AXMLSerializationSettings.IncludeTypeInfo) != 0)
{
r.Add(new XAttribute("type", type));
}
return(r);
}
public void Deserialize(XElement input, AXMLSerializationSettings opt)
{
if (input.Name.LocalName != "config")
{
throw new Exception("LocalName != 'config'");
}
Email = XHelper.GetChildValue(input, "Username", Email);
Password = Decrypt(XHelper.GetChildValue(input, "Password", string.Empty), opt);
UseSandbox = XHelper.GetChildValue(input, "UseSandbox", UseSandbox);
}
public void Deserialize(XElement input, AXMLSerializationSettings opt)
{
if (input.Name.LocalName != "config")
{
throw new Exception("LocalName != 'config'");
}
Folder = XHelper.GetChildValue(input, "Folder", string.Empty);
Extension = XHelper.GetChildValue(input, "Extension", "txt");
StrEncoding = XHelper.GetChildValue(input, "Encoding", "UTF-8");
SearchDepth = XHelper.GetChildValue(input, "SearchDepth", 8);
}
public void Deserialize(XElement input, AXMLSerializationSettings opt)
{
if (input.Name.LocalName != "config")
{
throw new Exception("LocalName != 'config'");
}
Username = XHelper.GetChildValue(input, "Username", Username);
Password = Decrypt(XHelper.GetChildValue(input, "Password", string.Empty), opt);
PermanentlyDeleteNotes = XHelper.GetChildValue(input, "PermanentlyDeleteNotes", PermanentlyDeleteNotes);
BlankLineBelowTitle = XHelper.GetChildValue(input, "BlankLineBelowTitle", BlankLineBelowTitle);
}
public void Deserialize(XElement input, AXMLSerializationSettings opt)
{
if (input.Name.LocalName != "config")
{
throw new Exception("LocalName != 'config'");
}
Email = XHelper.GetChildValue(input, "Email", Email);
Password = Decrypt(XHelper.GetChildValue(input, "Password", string.Empty), opt);
Server = XHelper.GetChildValue(input, "Server", Server);
RemEmptyTags = XHelper.GetChildValue(input, "RemEmptyTags", RemEmptyTags);
}
public XElement Serialize(AXMLSerializationSettings opt)
{
var data = new object[]
{
new XElement("Name", Name),
};
var r = new XElement("config", data);
r.SetAttributeValue("plugin", HeadlessPlugin.Name);
r.SetAttributeValue("pluginversion", HeadlessPlugin.Version.ToString());
return(r);
}
public void Serialize(XElement target, AXMLSerializationSettings opt)
{
foreach (var d in _data)
{
var x = new XElement("Value");
x.Add(new XAttribute("Key", d.Key));
if ((opt & AXMLSerializationSettings.IncludeTypeInfo) != 0)
{
x.Add(new XAttribute("type", d.Value.GetTypeStr()));
}
x.Value = d.Value.Serialize(opt);
target.Add(x);
}
}
public XElement Serialize(AXMLSerializationSettings opt)
{
var data = new object[]
{
new XElement("Username", Email),
new XElement("Password", Encrypt(Password, opt)),
new XElement("UseSandbox", UseSandbox),
};
var r = new XElement("config", data);
r.SetAttributeValue("plugin", EvernotePlugin.Name);
r.SetAttributeValue("pluginversion", EvernotePlugin.Version.ToString());
return(r);
}
public XElement Serialize(AXMLSerializationSettings opt)
{
var data = new object[]
{
new XElement("Username", Username),
new XElement("Password", Encrypt(Password, opt)),
new XElement("PermanentlyDeleteNotes", PermanentlyDeleteNotes),
new XElement("BlankLineBelowTitle", BlankLineBelowTitle),
};
var r = new XElement("config", data);
r.SetAttributeValue("plugin", SimpleNotePlugin.Name);
r.SetAttributeValue("pluginversion", SimpleNotePlugin.Version.ToString());
return(r);
}
public XElement Serialize(AXMLSerializationSettings opt)
{
var data = new object[]
{
new XElement("Username", Username),
new XElement("Password", Encrypt(Password, opt)),
new XElement("Host", Host),
new XElement("BlankLineBelowTitle", BlankLineBelowTitle),
};
var r = new XElement("config", data);
r.SetAttributeValue("plugin", NextcloudPlugin.Name);
r.SetAttributeValue("pluginversion", NextcloudPlugin.Version.ToString());
return(r);
}
public XElement Serialize(AXMLSerializationSettings opt)
{
var data = new object[]
{
new XElement("Email", Email),
new XElement("Password", Encrypt(Password, opt)),
new XElement("Server", Server),
new XElement("RemEmptyTags", RemEmptyTags),
};
var r = new XElement("config", data);
r.SetAttributeValue("plugin", StandardNotePlugin.Name);
r.SetAttributeValue("pluginversion", StandardNotePlugin.Version.ToString());
return(r);
}
public XElement Serialize(AXMLSerializationSettings opt)
{
var data = new object[]
{
new XElement("Folder", Folder),
new XElement("Extension", Extension),
new XElement("Encoding", StrEncoding),
new XElement("SearchDepth", SearchDepth),
};
var r = new XElement("config", data);
r.SetAttributeValue("plugin", FilesystemPlugin.Name);
r.SetAttributeValue("pluginversion", FilesystemPlugin.Version.ToString());
return(r);
}
public object DeserializeNew(string source, AXMLSerializationSettings opt)
{
if (string.IsNullOrWhiteSpace(source))
{
return(new ShortcutDefinition(AlephShortcutScope.None, AlephModifierKeys.None, AlephKey.None));
}
var kk = AlephKey.None;
var mm = AlephModifierKeys.None;
var ss = AlephShortcutScope.Window;
source = source.Trim();
foreach (var v in Enum.GetValues(typeof(AlephShortcutScope)).Cast <AlephShortcutScope>())
{
var estr = $"[{v.ToString().ToLower()}]";
if (source.ToLower().EndsWith(estr))
{
ss = v;
source = source.Substring(0, source.Length - estr.Length).Trim();
break;
}
}
foreach (var elem in source.Split('+'))
{
if (Enum.TryParse <AlephModifierKeys>(elem.Trim(), true, out var mk))
{
mm = mm | mk;
continue;
}
if (Enum.TryParse <AlephKey>(elem.Trim(), true, out var pk))
{
kk = pk;
continue;
}
throw new Exception($"Unknown KeyCode: '{elem}'");
}
if (kk == AlephKey.None)
{
throw new Exception($"Keycode 'None' is no supported");
}
return(new ShortcutDefinition(ss, mm, kk));
}
public void Deserialize(T obj, string xml, AXMLSerializationSettings opt)
{
var xd = XDocument.Parse(xml);
var root = xd.Root;
if (root == null)
{
throw new Exception("XDocument needs root");
}
foreach (var prop in _fields)
{
prop.Deserialize(obj, root, opt);
}
obj.OnAfterDeserialize();
}
public void Serialize(XElement target, AXMLSerializationSettings opt)
{
foreach (var d in Data)
{
var x = new XElement("Value");
x.Add(new XAttribute("Key", d.Key));
if ((opt & AXMLSerializationSettings.IncludeTypeInfo) != 0)
{
x.Add(new XAttribute("type", "GenericValue"));
}
var s = new XElement("GenericValue");
d.Value.Serialize(s, opt);
x.Add(s);
target.Add(x);
}
}
public string Serialize(T obj, AXMLSerializationSettings opt)
{
obj.OnBeforeSerialize();
var root = new XElement(_rootNode);
foreach (var prop in _fields)
{
var data = prop.PropInfo.GetValue(obj);
root.Add(prop.Serialize(data, opt));
}
if ((opt & AXMLSerializationSettings.FormattedOutput) != 0)
{
return(XHelper.ConvertToStringFormatted(new XDocument(root)));
}
else
{
return(XHelper.ConvertToStringRaw(new XDocument(root)));
}
}
public static string SimpleEncryptWithPassword(string secretMessage, string password, AXMLSerializationSettings opt)
{
if ((opt & AXMLSerializationSettings.UseEncryption) == 0)
{
return(secretMessage);
}
if (string.IsNullOrWhiteSpace(secretMessage))
{
return(string.Empty);
}
var encbytes = EncodeBytes(Encoding.UTF32.GetBytes(secretMessage), password);
return(":02:" + Convert.ToBase64String(encbytes));
}
public static string SimpleEncryptWithPassword(string secretMessage, string password, AXMLSerializationSettings opt)
{
if ((opt & AXMLSerializationSettings.UseEncryption) == 0)
{
return(secretMessage);
}
return(AESThenHMAC.SimpleEncryptWithPassword(secretMessage, password));
}
public object DeserializeNew(XElement source, AXMLSerializationSettings opt)
{
var d = source.Elements("Value").Select(p => Tuple.Create(p.Attribute("Key").Value, p.Value)).ToArray();
return(new KeyValueStringList(d));
}
public object DeserializeNew(XElement source, AXMLSerializationSettings opt)
{
var d = source.Elements("Value").Select(p => Tuple.Create(p.Attribute("Key").Value, (TValue)DefaultDictValue.DeserializeNew(p.Value, opt))).ToArray();
return(new KeyValueFlatCustomList <TValue>(d, DefaultDictValue));
}
public static string SimpleDecryptWithPassword(string encryptedMessageStr, string password, AXMLSerializationSettings opt)
{
if ((opt & AXMLSerializationSettings.UseEncryption) == 0)
{
return(encryptedMessageStr);
}
if (string.IsNullOrWhiteSpace(encryptedMessageStr))
{
return(string.Empty);
}
if (!encryptedMessageStr.StartsWith(":"))
{
// VERSION 1
var encryptedMessage = Convert.FromBase64String(encryptedMessageStr);
var cryptSalt = new byte[SaltBitSize / 8];
var authSalt = new byte[SaltBitSize / 8];
//Grab Salt from Non-Secret Payload
Array.Copy(encryptedMessage, 0, cryptSalt, 0, cryptSalt.Length);
Array.Copy(encryptedMessage, 0 + cryptSalt.Length, authSalt, 0, authSalt.Length);
byte[] cryptKey;
byte[] authKey;
//Generate crypt key
using (var generator = new Rfc2898DeriveBytes(password, cryptSalt, Iterations_v1))
{
cryptKey = generator.GetBytes(KeyBitSize / 8);
}
//Generate auth key
using (var generator = new Rfc2898DeriveBytes(password, authSalt, Iterations_v1))
{
authKey = generator.GetBytes(KeyBitSize / 8);
}
return(Encoding.UTF32.GetString(SimpleDecrypt(encryptedMessage, cryptKey, authKey, cryptSalt.Length + authSalt.Length + 0)));
}
else if (encryptedMessageStr.StartsWith(":02:"))
{
// VERSION 2
encryptedMessageStr = encryptedMessageStr.Substring(4);
var encbytes = Convert.FromBase64String(encryptedMessageStr);
var rawbytes = DecodeBytes(encbytes, password);
return(Encoding.UTF32.GetString(rawbytes));
}
else
{
throw new ArgumentException("Unknown encryption version: " + encryptedMessageStr, nameof(encryptedMessageStr));
}
}
public static string SimpleDecryptWithPassword(string encryptedMessageStr, string password, AXMLSerializationSettings opt)
{
if ((opt & AXMLSerializationSettings.UseEncryption) == 0)
{
return(encryptedMessageStr);
}
return(AESThenHMAC.SimpleDecryptWithPassword(encryptedMessageStr, password));
}
public object DeserializeNew(XElement source, AXMLSerializationSettings opt)
{
return(new SnippetDefinition(source.Attribute("display").Value, source.Attribute("value").Value));
}
private string Decrypt(string data, AXMLSerializationSettings opt)
{
return(ANEncryptionHelper.SimpleDecryptWithPassword(data, ENCRYPTION_KEY, opt));
}
private string Encrypt(string data, AXMLSerializationSettings opt)
{
return(AESThenHMAC.SimpleEncryptWithPassword(data, ENCRYPTION_KEY, opt));
}
public string Serialize(AXMLSerializationSettings opt)
{
return(Serialize());
}
public void Serialize(XElement target, AXMLSerializationSettings opt)
{
target.Add(new XAttribute("display", DisplayName));
target.Add(new XAttribute("value", Value));
}
