示例#1
0
        protected void AddBrokenNode(ref NodeMapping nm, Address addr, int broken_port, bool nctunnel)
        {
            nm.Node = new StructuredNode(addr as AHAddress, BrunetNamespace);

            TAAuthorizer auth = new IDTAAuthorizer(broken_port);

            nm.Node.AddEdgeListener(new SimulationEdgeListener(nm.ID, 0, auth, true));

            IRelayOverlap ito = null;

            if (NCEnable)
            {
                nm.NCService = new NCService(nm.Node, new Point());
// Until we figure out what's going on with VivaldiTargetSelector its not quite useful for these purposes
//        (nm.Node as StructuredNode).Sco.TargetSelector = new VivaldiTargetSelector(nm.Node, ncservice);
            }
            if (nctunnel && NCEnable)
            {
                ito = new NCRelayOverlap(nm.NCService);
            }
            else
            {
                ito = new SimpleRelayOverlap();
            }

            nm.Node.AddEdgeListener(new Relay.RelayEdgeListener(nm.Node, ito));
            nm.Node.RemoteTAs = GetRemoteTAs();
            nm.Node.Connect();
            CurrentNetworkSize++;
        }
示例#2
0
        protected virtual StructuredNode PrepareNode(int id, AHAddress address)
        {
            if (TakenIDs.ContainsKey(id))
            {
                throw new Exception("ID already taken");
            }

            StructuredNode node = new StructuredNode(address, BrunetNamespace);

            NodeMapping nm = new NodeMapping();

            nm.ID        = id;
            TakenIDs[id] = nm;
            nm.Node      = node;
            Nodes.Add((Address)address, nm);

            EdgeListener el = CreateEdgeListener(nm.ID);

            if (_secure_edges || _secure_senders)
            {
                byte[] blob = _se_key.ExportCspBlob(true);
                RSACryptoServiceProvider rsa_copy = new RSACryptoServiceProvider();
                rsa_copy.ImportCspBlob(blob);

                string           username = address.ToString().Replace('=', '0');
                CertificateMaker cm       = new CertificateMaker("United States", "UFL",
                                                                 "ACIS", username, "*****@*****.**", rsa_copy,
                                                                 address.ToString());
                Certificate cert = cm.Sign(_ca_cert, _se_key);

                CertificateHandler ch = null;
                if (_dtls)
                {
                    ch = new OpenSslCertificateHandler();
                }
                else
                {
                    ch = new CertificateHandler();
                }
                ch.AddCACertificate(_ca_cert.X509);
                ch.AddSignedCertificate(cert.X509);

                if (_dtls)
                {
                    nm.SO = new DtlsOverlord(rsa_copy, ch, PeerSecOverlord.Security);
                }
                else
                {
                    nm.Sso = new SymphonySecurityOverlord(node, rsa_copy, ch, node.Rrm);
                    nm.SO  = nm.Sso;
                }

                var brh = new BroadcastRevocationHandler(_ca_cert, nm.SO);
                node.GetTypeSource(BroadcastRevocationHandler.PType).Subscribe(brh, null);
                ch.AddCertificateVerification(brh);
                nm.SO.Subscribe(node, null);
                node.GetTypeSource(PeerSecOverlord.Security).Subscribe(nm.SO, null);
            }

            if (_pathing)
            {
                nm.PathEM = new PathELManager(el, nm.Node);
                nm.PathEM.Start();
                el = nm.PathEM.CreatePath();
                PType path_p = PType.Protocol.Pathing;
                nm.Node.DemuxHandler.GetTypeSource(path_p).Subscribe(nm.PathEM, path_p);
            }

            if (_secure_edges)
            {
                node.EdgeVerifyMethod = EdgeVerify.AddressInSubjectAltName;
                el = new SecureEdgeListener(el, nm.SO);
            }

            node.AddEdgeListener(el);

            if (!_start)
            {
                node.RemoteTAs = GetRemoteTAs();
            }

            IRelayOverlap ito = null;

            if (NCEnable)
            {
                nm.NCService = new NCService(node, new Point());
// My evaluations show that when this is enabled the system sucks
//        (node as StructuredNode).Sco.TargetSelector = new VivaldiTargetSelector(node, ncservice);
                ito = new NCRelayOverlap(nm.NCService);
            }
            else
            {
                ito = new SimpleRelayOverlap();
            }

            if (_broken != 0)
            {
                el = new Relay.RelayEdgeListener(node, ito);
                if (_secure_edges)
                {
                    el = new SecureEdgeListener(el, nm.SO);
                }
                node.AddEdgeListener(el);
            }

            BroadcastHandler bhandler = new BroadcastHandler(node as StructuredNode);

            node.DemuxHandler.GetTypeSource(BroadcastSender.PType).Subscribe(bhandler, null);
            node.DemuxHandler.GetTypeSource(SimBroadcastPType).Subscribe(SimBroadcastHandler, null);

            // Enables Dht data store
            new TableServer(node);
            nm.Dht      = new Dht(node, 3, 20);
            nm.DhtProxy = new RpcDhtProxy(nm.Dht, node);
            return(node);
        }
示例#3
0
        public void Test()
        {
            Address addr_x = new AHAddress(new RNGCryptoServiceProvider());

            byte[] addrbuff = Address.ConvertToAddressBuffer(addr_x.ToBigInteger() + (Address.Full / 2));
            Address.SetClass(addrbuff, AHAddress._class);
            Address addr_y = new AHAddress(addrbuff);

            List <Connection> connections = new List <Connection>();
            ConnectionTable   ct_x        = new ConnectionTable();
            ConnectionTable   ct_y        = new ConnectionTable();
            ConnectionTable   ct_empty    = new ConnectionTable();
            NCService         ncservice   = new NCService();

            Connection fast_con = null;

            for (int i = 1; i <= 11; i++)
            {
                addrbuff = Address.ConvertToAddressBuffer(addr_x.ToBigInteger() + (i * Address.Full / 16));
                Address.SetClass(addrbuff, AHAddress._class);
                Address    addr = new AHAddress(addrbuff);
                Connection con  = null;

                TransportAddress ta = TransportAddressFactory.CreateInstance("brunet.tcp://158.7.0.1:5000");
                Edge             fe = new FakeEdge(ta, ta, TransportAddress.TAType.Tcp);
                if (i <= 10)
                {
                    con = new Connection(fe, addr, "structured", null, null);
                    ct_x.Add(con);
                    if (i % 2 == 0)
                    {
                        ncservice.ProcessSample(DateTime.UtcNow, String.Empty, addr,
                                                new Point(new double[] { 0, 0 }, 0), 0, i * 10);
                    }
                }
                else
                {
                    fast_con = new Connection(fe, addr, "structured", null, null);
                    ncservice.ProcessSample(DateTime.UtcNow, String.Empty, addr,
                                            new Point(new double[] { 0, 0 }, 0), 0, 5);
                }

                if (i == 10)
                {
                    ct_y.Add(con);
                }
                connections.Add(con);
            }

            IRelayOverlap sto = new SimpleRelayOverlap();
            IRelayOverlap nto = new NCRelayOverlap(ncservice);

            ConnectionType    con_type = ConnectionType.Structured;
            List <Connection> pre_cons = new List <Connection>();

            pre_cons.Add(connections[9]);
            IDictionary id = nto.GetSyncMessage(pre_cons, addr_x, ct_x.GetConnections(con_type));

            // We do have some pre-existing overlap
            Assert.AreEqual(nto.EvaluateOverlap(ct_y.GetConnections(con_type), id)[0], connections[9], "NC: Have an overlap!");
            Assert.AreEqual(sto.EvaluateOverlap(ct_y.GetConnections(con_type), id)[0], connections[9], "Simple: Have an overlap!");

            // We have no overlap with an empty connection table
            Assert.AreEqual(nto.EvaluateOverlap(ct_empty.GetConnections(con_type), id).Count, 0, "No overlap!");
            Assert.AreEqual(sto.EvaluateOverlap(ct_empty.GetConnections(con_type), id).Count, 0, "No overlap!");

            // latency[0] == -1
            Assert.AreEqual(connections[1].Address.Equals(nto.EvaluatePotentialOverlap(id)), true,
                            "NC: EvaluatePotentialOverlap returns expected!");
            Assert.AreEqual(ct_x.Contains(con_type, sto.EvaluatePotentialOverlap(id)), true,
                            "Simple: EvaluatePotentialOverlap returns valid!");

            ct_y.Add(fast_con);
            ct_x.Add(fast_con);
            id = nto.GetSyncMessage(pre_cons, addr_x, ct_x.GetConnections(con_type));
            Assert.AreEqual(fast_con.Address.Equals(nto.EvaluatePotentialOverlap(id)), true,
                            "NC: EvaluatePotentialOverlap returns expected!");
            Assert.AreEqual(nto.EvaluateOverlap(ct_y.GetConnections(con_type), id)[0], fast_con, "NC: Have better overlap!");
        }
示例#4
0
        /// <summary>Creates an ApplicationNode and prepares it for connection to
        /// the overlay.  For historical reasons it is linked to _node, _dht,
        /// _rpc_dht, and _bso.</summary>
        public virtual ApplicationNode CreateNode(NodeConfig node_config)
        {
            // Get a Node ID for the new Node
            AHAddress address = null;

            try {
                address = (AHAddress)AddressParser.Parse(node_config.NodeAddress);
            } catch {
                address = Utils.GenerateAHAddress();
            }

            // Create the Node state
            StructuredNode node = new StructuredNode(address, node_config.BrunetNamespace);

            _shutdown.OnExit += node.Disconnect;
            IEnumerable addresses = IPAddresses.GetIPAddresses(node_config.DevicesToBind);

            SecurityOverlord so = null;

            // Enable Security if requested
            if (node_config.Security.Enabled)
            {
                if (node_config.Security.SelfSignedCertificates)
                {
                    SecurityPolicy.SetDefaultSecurityPolicy(SecurityPolicy.DefaultEncryptor,
                                                            SecurityPolicy.DefaultAuthenticator, true);
                }

                byte[] blob = null;
                using (FileStream fs = File.Open(node_config.Security.KeyPath, FileMode.Open)) {
                    blob = new byte[fs.Length];
                    fs.Read(blob, 0, blob.Length);
                }

                RSACryptoServiceProvider rsa_private = new RSACryptoServiceProvider();
                rsa_private.ImportCspBlob(blob);

                CertificateHandler ch = null;
                if (node_config.Security.Dtls)
                {
                    ch = new OpenSslCertificateHandler(node_config.Security.CertificatePath,
                                                       address.ToString());
                }
                else
                {
                    ch = new CertificateHandler(node_config.Security.CertificatePath,
                                                address.ToString());
                }


                if (node_config.Security.SecureEdges)
                {
                    node.EdgeVerifyMethod = EdgeVerify.AddressInSubjectAltName;
                }

                // A hack to enable a test for security that doesn't require each peer
                // to exchange certificates
                if (node_config.Security.TestEnable)
                {
                    blob = rsa_private.ExportCspBlob(false);
                    RSACryptoServiceProvider rsa_pub = new RSACryptoServiceProvider();
                    rsa_pub.ImportCspBlob(blob);
                    CertificateMaker cm = new CertificateMaker("United States", "UFL",
                                                               "ACIS", "David Wolinsky", "*****@*****.**", rsa_pub,
                                                               "brunet:node:abcdefghijklmnopqrs");
                    Certificate cacert = cm.Sign(cm, rsa_private);

                    cm = new CertificateMaker("United States", "UFL",
                                              "ACIS", "David Wolinsky", "*****@*****.**", rsa_pub,
                                              address.ToString());
                    Certificate cert = cm.Sign(cacert, rsa_private);
                    ch.AddCACertificate(cacert.X509);
                    ch.AddSignedCertificate(cert.X509);
                }

                if (node_config.Security.Dtls)
                {
                    OpenSslCertificateHandler ssl_ch = ch as OpenSslCertificateHandler;
                    so = new DtlsOverlord(rsa_private, ssl_ch, new PType(20));
                    node.GetTypeSource(new PType(20)).Subscribe(so, null);
                }
                else
                {
                    so = new SymphonySecurityOverlord(node, rsa_private, ch, node.Rrm);
                    node.GetTypeSource(PeerSecOverlord.Security).Subscribe(so, null);
                }
                so.Subscribe(node, null);
            }

            // Add Dht
            new TableServer(node);
            IDht        dht       = new Dht(node, 3, 20);
            RpcDhtProxy dht_proxy = new RpcDhtProxy(dht, node);

            // Setup Vivaldi if requested
            IRelayOverlap ito       = null;
            NCService     ncservice = null;

            if (node_config.NCService.Enabled)
            {
                ncservice = new NCService(node, node_config.NCService.Checkpoint);

                if (node_config.NCService.OptimizeShortcuts)
                {
                    node.Ssco.TargetSelector = new VivaldiTargetSelector(node, ncservice);
                }
                ito = new NCRelayOverlap(ncservice);
            }
            else
            {
                ito = new SimpleRelayOverlap();
            }

            // Create the ApplicationNode
            ApplicationNode app_node = new ApplicationNode(node, dht, dht_proxy, ncservice, so);

            // Add Edge listeners
            EdgeListener el = null;

            foreach (NodeConfig.EdgeListener item in node_config.EdgeListeners)
            {
                el = CreateEdgeListener(item, app_node, addresses);
                if (node_config.Security.SecureEdgesEnabled)
                {
                    el = new SecureEdgeListener(el, so);
                }
                node.AddEdgeListener(el);
            }

            // Create the tunnel and potentially wrap it in a SecureEL
            el = new Relay.RelayEdgeListener(node, ito);
            if (node_config.Security.SecureEdgesEnabled)
            {
                el = new SecureEdgeListener(el, so);
            }
            node.AddEdgeListener(el);

            List <TransportAddress> RemoteTAs = null;

            if (node_config.RemoteTAs != null)
            {
                RemoteTAs = new List <TransportAddress>();
                foreach (String ta in node_config.RemoteTAs)
                {
                    RemoteTAs.Add(TransportAddressFactory.CreateInstance(ta));
                }
                node.RemoteTAs = RemoteTAs;
            }

            // Add XmlRpc
            if (node_config.XmlRpcManager.Enabled)
            {
                if (_xrm == null)
                {
                    _xrm = new XmlRpcManagerServer(node_config.XmlRpcManager.Port);
                }
                _xrm.Add(node, GetXmlRpcUri(app_node));
                new RpcDht(dht, node);
            }

            if (node_config.PrivateNodeConfig != null &&
                node_config.PrivateNodeConfig.Enabled)
            {
                CreatePrivateNode(app_node, NodeConfig.GetPrivateNodeConfig(node_config));
            }
            return(app_node);
        }