private void addTrustedNodeButton_Clicked(object sender, EventArgs args)
{
AddTrustedNodeDialog w = new AddTrustedNodeDialog(Dialog);
int result = w.Run();
if (result == (int)ResponseType.Ok)
{
TrustedNodeInfo tni = w.TrustedNodeInfo;
if (tni != null)
{
foreach (object[] row in trustedNodesListStore)
{
var thisInfo = (TrustedNodeInfo)row[0];
if (thisInfo.NodeId == tni.NodeId)
{
Gui.ShowErrorDialog("This node already exists!", base.Dialog);
return;
}
}
trustedNodesListStore.AppendValues(tni);
}
}
}
private void on_btnAdd_clicked(object sender, EventArgs e)
{
try {
PublicKey result = PublicKey.Parse(txtPublicKey.Buffer.Text);
if (Common.SHA512Str(result.Key) == Core.MyNodeID)
{
throw new Exception("Cannot add your own key!");
}
tni = new TrustedNodeInfo(result);
EditFriendDialog w = new EditFriendDialog(base.Dialog, ref tni);
int editResult = w.Run();
if (editResult == (int)ResponseType.Ok)
{
base.Dialog.Respond(ResponseType.Ok);
}
else
{
base.Dialog.Respond(ResponseType.Cancel);
}
base.Dialog.Destroy();
}
catch (Exception ex) {
Gui.ShowMessageDialog(String.Format("Invalid public key: {0}", ex.Message),
base.Dialog, Gtk.MessageType.Error, ButtonsType.Ok);
base.Dialog.Respond(ResponseType.None);
return;
}
}
private void OnAutoConnectItemToggled(object o, ToggledArgs args)
{
TreeIter iter;
if (autoConnectTreeStore.GetIter(out iter, new TreePath(args.Path)))
{
TrustedNodeInfo node = (TrustedNodeInfo)autoConnectTreeStore.GetValue(iter, 0);
node.AllowAutoConnect = !node.AllowAutoConnect;
autoConnectList.QueueDraw();
}
}
private void trustedNodesList_RowActivated(object sender, RowActivatedArgs args)
{
TreeIter iter;
if (trustedNodesList.Selection.GetSelected(out iter))
{
TrustedNodeInfo trustedNode = (TrustedNodeInfo)trustedNodesListStore.GetValue(iter, 0);
EditFriendDialog editDialog = new EditFriendDialog(Dialog, ref trustedNode);
editDialog.Run();
}
}
protected override void OnResponded(int responseId)
{
if (responseId == (int)ResponseType.Ok)
{
networkInfo.TrustedNodes.Clear();
foreach (object[] row in trustedNodesListStore)
{
TrustedNodeInfo tni = (TrustedNodeInfo)row[0];
networkInfo.TrustedNodes.Add(tni.NodeId, tni);
}
}
}
private bool IsNearby(TrustedNodeInfo info)
{
/*
* if (Core.ZeroconfManager != null) {
* foreach (NearbyNode nnode in Core.NearbyNodes) {
* if (nnode.NodeId == info.NodeID) {
* return true;
* }
* }
* }
*/
return(false);
}
public EditFriendDialog(Window parentWindow, ref TrustedNodeInfo tni) : base(parentWindow, "EditFriendDialog")
{
if (tni.Identifier != "")
{
nameLabel.Markup = "<b>" + tni.Identifier + "</b>";
}
else
{
nameLabel.Markup = "<b>[Unknown Nickname]</b>";
tni.Identifier = tni.NodeId;
}
nodeIdLabel.Markup = "<span font=\"monospace\">" + Common.Utils.FormatFingerprint(tni.NodeId, 8) + "</span>";
chkAllowProfile.Active = tni.AllowProfile;
chkAllowNetworkInfo.Active = tni.AllowNetworkInfo;
chkAllowSharedFiles.Active = tni.AllowSharedFiles;
chkAllowConnect.Active = tni.AllowConnect;
TreeViewColumn column;
column = connectionsTreeView.AppendColumn("Protocol", new CellRendererText(), "text", 0);
column = connectionsTreeView.AppendColumn("Address Details", new CellRendererText(), "text", 1);
column.Expand = true;
connectionsTreeView.AppendColumn("Supported", new CellRendererText(), "text", 2);
connectionsTreeView.AppendColumn("Connectable", new CellRendererText(), "text", 3);
ListStore addressListStore = new ListStore(typeof(string), typeof(string), typeof(string), typeof(string));
foreach (IDestination destination in tni.GetDestinations(Runtime.Core))
{
addressListStore.AppendValues(destination.FriendlyTypeName, destination.ToString(), "True", destination.CanConnect.ToString());
}
foreach (DestinationInfo info in tni.DestinationInfos)
{
if (!info.IsSupported(Runtime.Core))
{
addressListStore.AppendValues(info.FriendlyName, string.Join(", ", info.Data), "False", "False");
}
}
connectionsTreeView.Model = addressListStore;
keyTextView.Buffer.Text = new PublicKey(tni.Identifier, tni.PublicKey).ToArmoredString();
this.tni = tni;
}
private void ShowAutoConnectName(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
CellRendererText textCell = (CellRendererText)cell;
if (((TreeStore)model).IterDepth(iter) == 0)
{
NetworkInfo networkInfo = (NetworkInfo)model.GetValue(iter, 0);
textCell.Markup = String.Format("<b>{0}</b>", GLib.Markup.EscapeText(networkInfo.NetworkName));
}
else
{
TrustedNodeInfo node = (TrustedNodeInfo)model.GetValue(iter, 0);
textCell.Markup = String.Format("{0} <span size=\"small\" foreground=\"#666666\">({1})</span>",
node.Identifier,
node.NodeID);
}
}
private void ShowAutoConnectToggle(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
CellRendererToggle toggleCell = (CellRendererToggle)cell;
if (((TreeStore)model).IterDepth(iter) > 0)
{
TrustedNodeInfo node = (TrustedNodeInfo)model.GetValue(iter, 0);
toggleCell.Active = node.AllowAutoConnect;
toggleCell.Activatable = true;
toggleCell.Visible = true;
}
else
{
toggleCell.Visible = false;
}
}
public PrivateChatSubpage(Network network, Node node) : base()
{
this.node = node;
this.network = network;
this.trustedNodeInfo = network.TrustedNodes[node.NodeID];
if (trustedNodeInfo == null)
{
throw new Exception("Cannot have a private conversation with an untrusted node.");
}
base.userList.Parent.Visible = false;
base.SendMessage += base_SendMessage;
AddToChat(null, String.Format("Now talking with {0} ({1}).", trustedNodeInfo.Identifier, Common.FormatFingerprint(trustedNodeInfo.NodeID)));
AddToChat(null, "This conversation is secure.");
}
private bool network_ReceivedKey(Network network, ReceivedKeyEventArgs args)
{
try {
var publicKey = new PublicKey(args.Key.Info, args.Key.Key);
var nodeInfo = new TrustedNodeInfo(publicKey);
if (args.Node != null)
{
nodeInfo.Identifier = args.Node.NickName;
}
else
{
nodeInfo.Identifier = nodeInfo.NodeId;
}
// First person to connect? Put them in charge!
if (network.TrustedNodes.Count == 0)
{
LogItem(string.Format("[!] WARNING! {0} is now the admin!", publicKey.Nickname));
if (!settings.AdminIDs.Contains(nodeInfo.NodeId))
{
settings.AdminIDs.Add(nodeInfo.NodeId);
settings.SaveSettings();
}
return(true);
}
// Don't accept the key now, but keep it around
var keyDir = GetKeyDir(network);
var keyFile = GetKeyFileName(network, nodeInfo.NodeId);
if (IO.File.Exists(keyFile) == false)
{
if (IO.Directory.Exists(keyDir) == false)
{
IO.Directory.CreateDirectory(keyDir);
}
IO.File.WriteAllText(keyFile, publicKey.ToArmoredString());
}
} catch (Exception ex) {
LoggingService.LogError("Error in network_ReceivedKey: " + ex);
}
return(false);
}
private void ShowAutoConnectIP(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
CellRendererText textCell = (CellRendererText)cell;
if (((TreeStore)model).IterDepth(iter) > 0)
{
TrustedNodeInfo node = (TrustedNodeInfo)model.GetValue(iter, 0);
IDestination destination = node.FirstConnectableDestination;
if (destination == null)
{
textCell.Text = "<unknown>";
}
else
{
textCell.Text = destination.ToString();
}
}
else
{
textCell.Text = String.Empty;
}
}
private void ShowText(CellLayout cell_layout, CellRenderer cell, TreeModel tree_model, TreeIter iter)
{
object currentRow = tree_model.GetValue(iter, 0);
string address = (string)tree_model.GetValue(iter, 1);
if (currentRow is TrustedNodeInfo)
{
TrustedNodeInfo node = (currentRow as TrustedNodeInfo);
((CellRendererText)cell).Markup = string.Format("{0}\n<span size=\"small\">({1})</span>", node.Identifier, address);
cell.Sensitive = true;
}
else if (currentRow is NearbyNode)
{
NearbyNode node = (currentRow as NearbyNode);
((CellRendererText)cell).Markup = string.Format("{0}\n<span size=\"small\">({1})</span>", node.NickName, address);
cell.Sensitive = true;
}
else
{
((CellRendererText)cell).Markup = "<b>There are no friends to connect to.</b>";
cell.Sensitive = false;
}
}
private bool network_ReceivedKey(Network network, ReceivedKeyEventArgs args)
{
try {
var publicKey = new PublicKey(args.Key.Info, args.Key.Key);
TrustedNodeInfo nodeInfo = new TrustedNodeInfo(publicKey);
if (args.Node != null) {
nodeInfo.Identifier = args.Node.NickName;
} else {
nodeInfo.Identifier = nodeInfo.NodeID;
}
// First person to connect? Put them in charge!
if (network.TrustedNodes.Count == 0) {
LogItem(String.Format("[!] WARNING! {0} is now the admin!", publicKey.Nickname));
if (!settings.AdminIDs.Contains(nodeInfo.NodeID)) {
settings.AdminIDs.Add(nodeInfo.NodeID);
settings.SaveSettings();
}
return true;
}
// Don't accept the key now, but keep it around
string keyDir = GetKeyDir(network);
string keyFile = GetKeyFileName(network, nodeInfo.NodeID);
if (IO.File.Exists (keyFile) == false) {
if (IO.Directory.Exists (keyDir) == false) {
IO.Directory.CreateDirectory (keyDir);
}
IO.File.WriteAllText(keyFile, publicKey.ToArmoredString());
}
} catch (Exception ex) {
LoggingService.LogError("Error in network_ReceivedKey: " + ex);
}
return false;
}
private void NameFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
TrustedNodeInfo friend = (TrustedNodeInfo)model.GetValue(iter, 0);
(cell as CellRendererText).Text = friend.Identifier;
}
private string ProcessCommand(Network network, string[] args)
{
NetworkInfo networkInfo = null;
foreach (var n in settings.Networks)
{
if (n.NetworkId == network.NetworkID)
{
networkInfo = n;
break;
}
}
if (networkInfo == null)
{
throw new Exception("EGADS!!");
}
var result = string.Empty;
switch (args[0])
{
case "key":
if (args.Length > 1)
{
switch (args[1])
{
case "list":
result += "TRUSTED KEYS\n";
foreach (var n in network.TrustedNodes.Values)
{
result += " " + n.NodeId + "\n";
}
result += "\nUNTRUSTED KEYS\n";
foreach (var dir in new IO.DirectoryInfo("received_keys").GetDirectories())
{
if (dir.Name == network.NetworkID)
{
foreach (var file in dir.GetFiles())
{
result += " " + file.Name + "\n";
}
}
}
break;
case "trust":
if (args.Length > 2)
{
var id = args[2];
var keyDir = IO.Path.Combine("received_keys", network.NetworkID);
var keyFile = IO.Path.Combine(keyDir, id + ".mpk");
if (IO.File.Exists(keyFile))
{
var key = PublicKey.Parse(IO.File.ReadAllText(keyFile));
var nodeInfo = new TrustedNodeInfo(key);
networkInfo.TrustedNodes.Add(nodeInfo.NodeId, nodeInfo);
settings.SaveSettings();
core.Settings = settings;
IO.File.Delete(keyFile);
result += "Key added!";
}
else
{
result += "File not found.";
}
}
else
{
result += "Argument(s) expected: keyid";
}
break;
case "request":
if (args.Length > 2)
{
var nodeid = args[2];
var node = network.Nodes[nodeid];
if (node != null)
{
network.RequestPublicKey(node);
result += "Key requested!";
}
else
{
result += "Node not found!";
}
break;
}
else
{
result += "Argument(s) expected: nodeid";
}
break;
default:
result += "key list - show all keys\n";
result += "key trust <id> - trust a key\n";
result += "key request <id> - request a user's key\n";
break;
}
}
else
{
result += "Argument expected: key command.";
}
break;
case "admin":
if (args.Length > 1)
{
switch (args[1])
{
case "list":
result += "\nThere are " + settings.AdminIDs.Count + " admins:\n";
foreach (var id in settings.AdminIDs)
{
var info = networkInfo.TrustedNodes[id];
result += info.Identifier + " (" + id + ")\n";
}
break;
case "add":
if (args.Length > 2)
{
var id = args[2];
if (!settings.AdminIDs.Contains(id))
{
if (networkInfo.TrustedNodes[id] != null)
{
settings.AdminIDs.Add(id);
settings.SaveSettings();
}
else
{
result += "Cannot add untrusted node as admin!";
}
}
else
{
result += "Already an admin!";
}
}
else
{
result += "Argument expected: nodeid";
}
break;
case "remove":
if (args.Length > 2)
{
var id = args[2];
if (settings.AdminIDs.Count == 1)
{
result += "Cannot remove last admin.";
}
else
{
if (settings.AdminIDs.Contains(id))
{
settings.AdminIDs.Remove(id);
settings.SaveSettings();
}
else
{
result += "That ID is not an admin.";
}
}
}
else
{
result += "Argument expected: nodeid";
}
break;
default:
result += "admin list - show all admins\n";
result += "admin add <nodeid> - add new admin\n";
result += "admin remove <nodeid> - remove existing admin\n";
break;
}
}
else
{
result += "Argument expected: admin command.";
}
break;
default:
result += "Unknown command";
break;
}
return(result + "\n");
}
private string ProcessCommand(Network network, string[] args)
{
NetworkInfo networkInfo = null;
foreach (NetworkInfo n in settings.Networks) {
if (n.NetworkID == network.NetworkID) {
networkInfo = n;
break;
}
}
if (networkInfo == null) {
throw new Exception("EGADS!!");
}
string result = String.Empty;
switch (args[0]) {
case "key":
if (args.Length > 1) {
switch (args[1]) {
case "list":
result += "TRUSTED KEYS\n";
foreach (TrustedNodeInfo n in network.TrustedNodes.Values) {
result += " " + n.NodeID + "\n";
}
result += "\nUNTRUSTED KEYS\n";
foreach (IO.DirectoryInfo dir in new IO.DirectoryInfo("received_keys").GetDirectories()) {
if (dir.Name == network.NetworkID) {
foreach (IO.FileInfo file in dir.GetFiles()) {
result += " " + file.Name + "\n";
}
}
}
break;
case "trust":
if (args.Length > 2) {
string id = args[2];
string keyDir = IO.Path.Combine("received_keys", network.NetworkID);
string keyFile = IO.Path.Combine(keyDir, id + ".mpk");
if (IO.File.Exists(keyFile)) {
PublicKey key = PublicKey.Parse(IO.File.ReadAllText(keyFile));
TrustedNodeInfo nodeInfo = new TrustedNodeInfo(key);
networkInfo.TrustedNodes.Add(nodeInfo.NodeID, nodeInfo);
settings.SaveSettings();
Core.Settings = settings;
IO.File.Delete (keyFile);
result += "Key added!";
} else {
result += "File not found.";
}
} else {
result += "Argument(s) expected: keyid";
}
break;
case "request":
if (args.Length > 2) {
string nodeid = args[2];
Node node = network.Nodes[nodeid];
if (node != null) {
network.RequestPublicKey(node);
result += "Key requested!";
} else {
result += "Node not found!";
}
break;
} else {
result += "Argument(s) expected: nodeid";
}
break;
default:
result += "key list - show all keys\n";
result += "key trust <id> - trust a key\n";
result += "key request <id> - request a user's key\n";
break;
}
} else {
result += "Argument expected: key command.";
}
break;
case "admin":
if (args.Length > 1) {
switch (args[1]) {
case "list":
result += "\nThere are " + settings.AdminIDs.Count + " admins:\n";
foreach (string id in settings.AdminIDs) {
TrustedNodeInfo info = networkInfo.TrustedNodes[id];
result += info.Identifier + " (" + id + ")\n";
}
break;
case "add":
if (args.Length > 2) {
string id = args[2];
if (!settings.AdminIDs.Contains(id)) {
if (networkInfo.TrustedNodes[id] != null) {
settings.AdminIDs.Add(id);
settings.SaveSettings();
} else {
result += "Cannot add untrusted node as admin!";
}
} else {
result += "Already an admin!";
}
} else {
result += "Argument expected: nodeid";
}
break;
case "remove":
if (args.Length > 2) {
string id = args[2];
if (settings.AdminIDs.Count == 1) {
result += "Cannot remove last admin.";
} else {
if (settings.AdminIDs.Contains(id)) {
settings.AdminIDs.Remove(id);
settings.SaveSettings();
} else {
result += "That ID is not an admin.";
}
}
} else {
result += "Argument expected: nodeid";
}
break;
default:
result += "admin list - show all admins\n";
result += "admin add <nodeid> - add new admin\n";
result += "admin remove <nodeid> - remove existing admin\n";
break;
}
} else {
result += "Argument expected: admin command.";
}
break;
default:
result += "Unknown command";
break;
}
return result + "\n";
}
