Patent Publication Number: US-2023134929-A1

Title: Obscured routing

Description:
BACKGROUND 
     Routing in some types of network may require that an originator of a message in the network know the route the message will take through the network before sending the message. The originator of the message may need to generate a listing of the entire route, including any intermediary nodes in the network. This may ensure that the originator of the message is certain that the message will be able to reach its destination before the message is sent. 
     BRIEF SUMMARY 
     In an implementation, a first node computing device may send a separate forward stack of identifiers to neighbor node computing devices in a network. Each separate forward stack of identifiers may include a unique identifier for the neighbor node computing device to which it is sent. 
     The first node computing device may send a notification including an indication of a destination node computing device in the network to each of the neighbor node computing devices along with the forward stacks of identifiers. 
     The first node computing device may receive forward stacks of identifiers from the neighbor node computing devices. The received forward stacks of identifiers may include completed routes to the destination node computing device. Each completed route may be specified by unique identifiers added to the forward stack of identifiers by node computing devices in the network. A unique identifier in each of the forward stacks of identifiers may not be resolvable to an address by the first node computing device. 
     The first node computing device may send a message to one of the neighbor node computing devices based on a first unique identifier in a chosen one of the received forward stacks of identifiers. 
     Systems and techniques disclosed herein may allow for obscured routing. Additional features, advantages, and embodiments of the disclosed subject matter may be set forth or apparent from consideration of the following detailed description, drawings, and claims. Moreover, it is to be understood that both the foregoing summary and the following detailed description are examples and are intended to provide further explanation without limiting the scope of the claims. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The accompanying drawings, which are included to provide a further understanding of the disclosed subject matter, are incorporated in and constitute a part of this specification. The drawings also illustrate embodiments of the disclosed subject matter and together with the detailed description serve to explain the principles of embodiments of the disclosed subject matter. No attempt is made to show structural details in more detail than may be necessary for a fundamental understanding of the disclosed subject matter and various ways in which it may be practiced. 
         FIG.  1    shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  2    shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  3 A  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  3 B  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  3 C  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  4 A  shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  4 B  shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  4 C  shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  4 D  shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  4 E  shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  4 F  shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  5 A  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  5 B  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  5 C  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  6    shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  7 A  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  7 B  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  7 C  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  7 D  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  8    shows an example procedure suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  9    shows an example procedure suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  10 A  shows an example procedure suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  10 B  shows an example procedure suitable for obscured routing according to an implementation of the disclosed subject matter. 
         FIG.  11    shows a computer according to an embodiment of the disclosed subject matter. 
         FIG.  12    shows a network configuration according to an embodiment of the disclosed subject matter. 
     
    
    
     DETAILED DESCRIPTION 
     According to embodiments disclosed herein, obscured routing may allow for an originator of a message in a network to generate the entire route for the message while concealing the identity of intermediate nodes from the originator and from other intermediate nodes. A network may have a number of nodes. An individual node in the network may be connected directly to its immediate neighbor nodes and may know non-neighbor nodes, but may not know which nodes its neighbor nodes and non-neighbor nodes are directly connected to. A node which is directly connected to another node may be able to pass a message directly to that node if it is a neighbor node. A node may wish to send a message to another node in the network which is not one of its neighbor nodes. The originator node for the message may know the identity, or network address, of the destination node for the message. The destination node may not be a neighbor to the originator node, or to any neighbors of the originator node. The originator node may send a notification to its neighbor nodes that it intends to send a message to the destination node. The neighbor nodes may send the notification to their neighbor nodes, and so on until a neighbor node of the destination node receives the notification. A node may not send the notification to the neighbor node from which it received the notification to prevent cyclical propagation of the notification. Each node that receives the notification may, before passing the notification on to one its neighbor nodes, add a unique identifier for that neighbor node to a forward stack of identifiers. When the notification arrives at a neighbor node of the destination node, the forward stack of identifiers sent along with the notification may include a full route from the originator node to the destination node. Stacks of identifiers that reach a neighbor node of the destination node may be passed back to the originator node, which may choose one of the stacks of identifiers to use to send the message to the destination node. Each unique identifier in a forward stack of identifiers may be resolvable to the node it identifies only by the node that added it to the stack. This may allow for the creation of routes through a network that obscures the entirety of the route from all nodes in the route. Each node in the route may only be able determine the identity of its neighbor nodes in the route from a forward stack of identifiers. 
     A network may include any suitable number of nodes. The nodes may be, for example, single computing devices, multiple connected computing devices, individual servers, server farms, or distributed server systems, or virtual computing devices or systems. The nodes may be connected in any suitable manner, including, for example, wired and wireless data connections. The connections may be over any combination of the Internet and private networks. For example, the nodes of a network may be computer systems belonging to financial institutions. The network may be used by the financial institutions to communicate data regarding financial transactions, for example, in the completion of payments between financial institutions. 
     Each node in a network may store data on its neighbor nodes in the network. For example, a node may store a peer table. The peer table stored on a node may include an entry for each of its neighbor nodes. An entry for a neighbor node may include an address that can be used to send messages to the neighbor node, such as, for example, an IP address and port number, and a unique identifier for the neighbor node. The unique identifier may be unique to the node in which the peer table is stored. The same node may be a neighbor node to any number of other nodes, and the unique identifier for that neighbor node may be different in the peer tables on each of the other nodes. An entry for a neighbor node in a peer table may also include data indicating other nodes that may possibly be reached from the neighbor node. 
     A node in a network may wish to send a message to another node in the network. The message may be, for example, any suitable data in any suitable format that may be communicated across the network. For example, the message may be encapsulated in IP packets of any suitable type to be transmitted across the network. The node that wishes to send the message may be the originator node for the message, and the node to which the message is being sent may be the destination node for the message. The originator node may send a notification to its neighbor node indicating that the originator node wishes to send a message to the destination node. The originator node may send the notification to all of its neighbor nodes, or may only notify neighbor nodes from which the destination node may possibly be reached as indicated by data in the originator node’s peer table. The originator node may look up each neighbor node to which it will send a notification in the originator node’s peer table and retrieve the unique identifier that the originator node uses for the neighbor node. The unique identifier for the neighbor node may be used to start a forward stack of identifiers that may be sent along with the notification from the originator node. 
     A node that receives the notification from the originator node may notify its own neighbor nodes. The node may look up each neighbor node to which it will send the notification and forward stack of identifiers in the node’s peer table and retrieve the unique identifier that the node uses for the neighbor node. The unique identifier for the neighbor node may be added to the top of the forward stack of identifiers that may be sent along with the notification that was received from the originator node. The node may send the notification and forward stack of identifiers to all of its neighbor nodes except for the neighbor node from which it received the notification, or may only notify neighbor nodes from which the destination node may possibly be reached as indicated by data in the node’s peer table. 
     Each node that receives a notification from another node and is not a neighbor node of the destination node may handle the notification in the same manner as the nodes that received the notification from the originator node. This may result in any forward stack of identifiers that reaches a neighbor node of the destination node, along with the notification, including a complete route through the network from the originator node to the destination node. A forward stack of identifiers that reaches a neighbor node of the destination node along with the notification from the originator node may include a unique identifier for each node on the route the notification took from the originator node. The neighbor node to the destination node may add its own unique identifier for the destination node to the forward stack of identifiers, completing the route. Each unique identifier may only be resolvable to an address of a node using the peer table of the node that added the unique identifier to the forward stack of identifiers. This may prevent any node in a route from being able to identify any of the other nodes in the route that are not its neighbor nodes. 
     Stacks of identifiers that reach a neighbor node of the destination node may be returned to the originator node in any suitable manner. For example, the forward stack of identifiers may be returned through open connections between the nodes on the route included in the forward stack of identifiers. The originator node may maintain an open connection to each neighbor node to which the originator node sends the notification. Each node that sends the notification to its own neighbor nodes may maintain an open connection to each of those neighbor nodes. When a node that is a neighbor node to the destination node receives a forward stack of identifiers along with the notification, the node may complete the route by adding its own unique identifier for the destination node to the forward stack of identifiers. The node may then pass back the forward stack of identifiers to the node from which it received the notification using the still open connection. That node in turn may pass back the forward stack of identifiers to the node it received notification from using the still open connection, and so on using open connections until the forward stack of identifiers reaches the originator node. 
     There may be a limit on the length of a route in the network. The limit may be set by the originator node when it sends out the notification, or the limit may be set by, for example, a policy of the network. For example, the limit may be set at six hops. This may cause a node that both receives a forward stack of identifiers that already includes five unique identifiers and is not a neighbor node to the destination node to indicate that the route in the forward stack of identifiers has failed. The node may pass the forward stack of identifiers back to the originator node with an indication that the route has failed, or may pass a failure message back to the originator node. The limit on the length of the route may prevent notifications and forward stacks of identifiers from being passed around a network indefinitely without ever reaching the destination node. 
     The originator node may use a forward stack of identifiers to send a message to the destination node. The originator node may receive any number of forward stacks of identifiers that include complete route to the destination node. The originator node may choose a forward stack of identifiers to use to send the message based on any suitable criteria. For example, the originator node may choose the shortest forward stack of identifiers, which may include the route with the fewest number of nodes or may choose a forward stack of identifiers that uses a neighbor node that is most trusted by the originator node. 
     The originator node may look up the unique identifier at the bottom of the forward stack of identifiers in its peer table. This may be the unique identifier that was added to the forward stack of identifiers by the originator node before the notification was sent. The look-up may resolve the unique identifier to an address of a neighbor node of the originator node. The originator node may remove the unique identifier for the neighbor node from the forward stack of identifiers, and may use the address to send the message to the neighbor node along with the forward stack of identifiers. 
     The neighbor node of the originator node may receive the message and the forward stack of identifiers from the originator node. The neighbor node may look up the unique identifier at the bottom of the forward stack of identifiers. This may now be the unique identifier that was added to the forward stack of identifiers by the neighbor node of the originator node. The unique identifier for the neighbor node of the originator node, added by the originator node, may have been removed from the forward stack of identifiers by the originator node. The look-up may resolve the unique identifier to an address of a neighbor node of the neighbor node to the originator node. The neighbor node of the originator node may remove the unique identifier for its neighbor node from the forward stack of identifiers, and may use the address to send the message to its neighbor node along with the forward stack of identifiers. 
     Each node that receives the message and forward stack of identifiers may repeat the actions of the neighbor node of the originator node until the forward stack of identifiers is empty. The node that receives the message but no forward stack of identifiers may be the destination node, as its neighbor node in the route may have been the last node the added a unique identifier to the forward stack of identifiers. The message may thus be delivered from the originator node to the destination node using the route specified in the forward stack of identifiers. Each node that receives the forward stack of identifiers may only be able to resolve the unique identifier for its own neighbor node, as the unique identifiers may be unique to each node such that the same node may be identified by different unique identifiers in the peer tables of different nodes. Each node in the route after the originator node may therefore only be able to identify its immediate neighbor nodes in the route. The originator node may only know its neighbor node in the route and the destination node. The destination node may know its neighbor in the route, and may know the originator node if the message includes information identifying the originator node. 
     In some implementations, messaging between the originator node and the destination node may be synchronous. The originator node may maintain an open connection with its neighbor node in the route in the forward stack of identifiers after the message is sent from the originator node to the neighbor node. Each node in the route may likewise maintain an open connection to its neighbor node that is the next node in the route after sending the message to that neighbor node. Once the message has reached the destination node using the route in the forward stack of identifiers, there may be open connections between each node in the route from the originator node to the destination node. This may allow messages to be passed back and forth across the nodes in the route between the originator node and the destination node without requiring any further use of the forward stack of identifiers or any additional peer table look-ups by any nodes in the route. The connections may be closed at any suitable time, in any suitable manner, by any suitable node in the route. 
     In some implementations, messaging between the originator node and the destination node may be asynchronous. The originator node may disconnect from its neighbor node in the route in the forward stack of identifiers after the message is sent from the originator node to the neighbor node. Each node in the route may likewise disconnect from its neighbor node that is the next node in the route after sending the message to that neighbor node. A return stack of identifiers may be used to allow for messages to be sent back to the originator node from the destination node using the nodes in the route in the forward stack of identifiers. 
     The return stack of identifiers may be started by the node in the route that is the neighbor node of the originator node. The neighbor node of the originator node may look up the originator node in the neighbor node’s peer table and retrieve the unique identifier that the neighbor node of the originator node uses for the originator node. The unique identifier for the originator node may be used to start the return stack of identifiers. The return stack of identifiers may be included with the forward stack of identifiers and the message sent from the neighbor node of the originator node to the next node in the route. 
     Each node that receives the message, forward stack of identifiers, and return stack of identifiers from one of its neighbor nodes in the route may look up that neighbor node in the node’s peer table and retrieve the unique identifier that the node uses for the neighbor node. The unique identifier for the neighbor node from which the message was received may be added to the top of the return stack of identifiers. In this way, each node may add to the return stack of identifiers that node’s unique identifier for the neighbor node from which it receives the message as the message travels from the originator node to the destination node. When the message reaches the destination node, the destination node may likewise lookup its unique identifier for the node it received the message from and add it to the top of the return stack of identifiers. The return stack of identifiers may include a route back to the originator node from the destination node that goes through the same nodes in the route that was in the forward stack of identifiers that was used by the originator node. The forward stack of identifiers may be empty. Each unique identifier in the return stack of identifiers may only be resolvable to an address of a node using the peer table of the node that added the unique identifier to the return stack of identifiers. This may prevent any node in a route from being able to identify any of the other nodes in the route that are not its neighbor nodes. The destination node may use the return stack of identifiers to send a message to the originator node in the same manner that the originator node used the forward stack of identifiers to send its message to the destination node. 
     An originator node may receive more than one forward stack of identifiers after sending out a notification of its intent to send a message. The originator node may choose which forward stack of identifiers to use to send the message based on, for example, costs associated with the forward stacks of identifiers. Different types of networks may include different types of costs associated with stacks of identifiers. For example, the costs may be financial costs, including, for example, tolls or fees that may be charged to the originator node for sending a message using certain nodes, or for using the connections between nodes. Financial costs may also be transaction fees imposed by financial institutions when the network is a network of financial institutions and the message is related to the completion of transactions at the originator node and destination node, for example, as in correspondent banking. The costs may also be, for example, latency in delivering a message between nodes. For example, a forward stack of identifiers with a longer route through a communication network may have a lower cost than another forward stack of identifiers with a shorter route due to high latency between nodes on the shorter route. The originator nodes may determine the cost of a forward route in any suitable manner. For example, the originator node may use the forward stack of identifiers to send a quote request across the route in the same manner that a message would be sent. Each node that receives the quote request may append its cost, which may be a cost imposed by the node itself or a cost of reaching that node from its neighbor node, to the quote request. When the quote request reaches the destination node, the destination node may append its cost to the quote request, which may then be returned to the originator node. The quote request may be returned across open connections in synchronous messaging, or using a return stack of identifiers in asynchronous messaging. The quote request may allow the originator node to see the costs associated with each hop and node in the route of the forward stack of identifiers, but the nodes may still only be identified using their unique identifiers from the forward stack of identifiers. This may prevent the originator node from determining the identity of any of the nodes in the route that are the destination node or neighbor nodes to the originator node 
     A stack of identifiers may be cached, allowing for reuse of the route in the stack of identifiers. For example, the originator node may cache a forward stack of identifiers used to send a message to a destination node, and the destination node may cache a return stack of identifiers used to send a message back to the originator node. This may allow for the re-use of the routes in the stacks of identifiers without requiring that the routes be re-found. A time-to-live may be associated with a stack of identifiers, so that a cached stack of identifiers may expire at the end of its time-to-live. 
     In some implementations, the forward stack of identifiers may not be returned to the originator node. Instead, a forward stack of identifiers that includes a route to the destination node may be returned to the node in the route that is the neighbor node of the originator node. This neighbor node may then then inform the originator node that a route has been found to the destination node without revealing additional information about the route. For example, the node may not reveal the length of the route to the originator node. The originator node may decide whether or not to send the message using the route. If the originator node decides to use the route, the message may be sent to the neighbor node to which the forward stack of identifiers was returned, which may then send the message and the forward stack of identifiers to the next node in the route. If the originator node sends out a quote request, the cost of the entire route may be returned to the originator node without any itemization of the costs associated with each node or hop in the route. More than one forward stack of identifiers may be returned to the same neighbor node of the originator node, indicating that more than one route was found from the originator node to the destination node using that neighbor node as the first node in the route after the originator node. The neighbor node may still only inform the originator node that a route starting with the neighbor node has been found, and may not inform the originator node that there is more than one route that starts with the neighbor node available. If the originator node decides to send the message through the neighbor node, the neighbor node may choose the route that is used. This may allow the neighbor node to balance outgoing traffic among its neighbor nodes, and may also present opportunities for the neighbor node to achieve cost savings through volume discounts offered by its neighbor nodes. 
     Communication between the computing devices and systems that are the nodes of a network may occur directly, for example, between any of the connectors and ledgers, or may be routed in any suitable manner. Communications may occur directly using any suitable communications protocols, such as, for example, HTTPS. In some implementations, instead of messages being sent by one computing device or system to another, a computing device or system may check for a message on another computing device or system. Computing devices and system may communicate using any suitable communications hardware, including, for example, any suitable wired and wireless network adapters. 
       FIG.  1    shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. A node computing device  100  may include a communications controller  110  and a storage  140 . The node computing device  100  may be any suitable computing device, such as, for example, a computer  20  as described in  FIG.  11   , or component thereof, for implementing the communications controller  110 , and the storage  140 . The node computing device  100  may be a single computing device, or may include multiple connected computing devices, and may be, for example, a laptop, a desktop, an individual server, a server farm, or a distributed server system, or may be a virtual computing device or system. The node computing device  100  may be part of a computing system and network infrastructure, or may be otherwise connected to the computing system and network infrastructure. The node computing device  100  may be, for example, a computing device that is part of a financial institution such as a centralized ledger, or may be a distributed computing system such as, for example, a blockchain ledger or other distributed ledger system. The communications controller  110  may be any suitable combination of hardware and software on the node computing device  100  for controlling communications between the node computing device  100  and other node computing devices in a network. The storage  140  may be any suitable hardware storage with any suitable software on, or accessible to, the node computing device  100 , and may store a peer table  142  and cached routes  152 . 
     The communications controller  110  may be any suitable combination of hardware and software on the node computing device  100  for controlling communications between the node computing device  100  and other node computing devices in a network. The communications controller  110  may be able to send and receive messages, notifications, quotes, quote requests, and forward and return stacks of identifiers directly to and from any node computing device in the network to which the node computing device  100  has a direct connection. The communications controller  110  may also pass received messages to other components of the node computing device  100  where they may be used in any suitable manner, including, for example, to cause a transfer between accounts tracked by the node computing device  100 , which may be a computing device for a financial institution. The communications controller  110  may perform look-ups using the peer table  142  in order to retrieve unique identifiers to be added to forward and return stacks of identifiers, and to resolve unique identifiers removed from forward and return stacks to addresses of node computing devices. The communications controller  110  may use any suitable network communications protocols to communicate with other node computing devices over any suitable type of network connection, including wired and wireless connections, public Internet connections, intranet connections, and public and private wide area network connections. The communications controller  110  may use any suitable security and authentication protocols, including, for example, key-hashed message authentication codes (HMAC) for message authentication. 
     The storage  140  may be any suitable hardware storage and any suitable software, may be on, or accessible to, the node computing device  100 , and may store the peer table  142  and the cached routes  152 . The peer table  142  may store entries for each node computing device is the network that is a neighbor node of the node computing device  100 . An entry for a neighbor node in the peer table  142  may include an address that can be used to send messages to the neighbor node, such as, for example, an IP address and port number for a node computing device, and a unique identifier used for the neighbor node by the node computing device  100 . The unique identifier for a neighbor node to the node computing device  100  in the peer table  142  may be unique to the node computing device  100 . An entry for a neighbor node in the peer table  142  may also include data indicating other nodes that may possibly be reached from the neighbor node. 
     The unique identifiers in the peer table  142  may be generated in any suitable manner. For example, the unique identifiers for a neighbor node in the peer table  142  may be partially based on some data that may be unique to the node computing device  100 , such as, for example, MAC addresses of communications devices, which may be, for example, hashed. This hash of data unique to the node computing device  100  may be combined with, for example, a randomly generated string of characters to create the unique identifier for the neighbor node. The use of data unique to the node computing device  100  may ensure that the unique identifiers in the peer table  142  don’t collide with unique identifiers in the peer tables of other node computing devices. In some implementations, the unique identifiers may be generated in a manner that does not ensure a lack of collisions. In the event of a collision where two node computing devices assign the same unique identifier to a common neighbor node, neither node computing device could ever be certain that a collision had occurred. Neither node computing device can be sure what address the other node computing device would resolve the collided unique identifier to, and therefore what node computing device the collided unique identifier represents. Thus, even if both node computing devices resolve the collided identifier to the same address, for the node computing device that is a common neighbor to them, and both saw the collided unique identifier in a stack of identifiers where it was placed by the other node computing device, neither of the node computing devices could be certain that the other node computing device would resolve the unique identifier to the address for the common neighbor node. 
       FIG.  2    shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. A network may be formed from any number of nodes, which may be, for example, node computing devices  100 ,  201 ,  202 ,  203 ,  204 ,  205 ,  206 ,  207 ,  208 ,  209 ,  210 ,  211 ,  212 ,  213 ,  214 ,  215 , and  216 . The node computing devices  100 ,  201 ,  202 ,  203 ,  204 ,  205 ,  206 ,  207 ,  208 ,  209 ,  210 ,  211 ,  212 ,  213 ,  214 ,  215 , and  216  in the network may be connected in any suitable manner, for example, using any suitable type of communications links. In some networks, nodes which may be connected by a communications link may not be connected within the network, for example, due to lack of proper arrangements between the nodes. For example, in a financial network, the computing devices of two financial institutions may be able to communicate over the Internet, but may not be connected within the financial network due to lack of arraignments between the financial institutions. This may prevent the financial institutions from delivering payments to each other directly, requiring that such payments be routed through other nodes, for example, the computing devices of other financial institutions, within the network. 
     The node computing devices  100 ,  201 ,  202 ,  203 ,  204 ,  205 ,  206 ,  207 ,  208 ,  209 ,  210 ,  211 ,  212 ,  213 ,  214 ,  215 , and  216  that are directly connected to each other may be neighbor nodes in the network. For example, the node computing device  100  may be neighbor nodes with the node computing devices  207  and  209 . The node computing device  201  may be neighbor nodes with the node computing device  207 . The node computing device  202  may be neighbor nodes with the node computing devices  203  and  205 . The node computing device  203  may be neighbor nodes with the node computing devices  202  and  205 . The node computing device  204  may be neighbor nodes with the node computing devices  206 . The node computing device  205  may be neighbor nodes with the node computing devices  202 ,  203 ,  207 , and  208 . The node computing device  206  may be neighbor nodes with the node computing devices  204  and  210 . The node computing device  207  may be neighbor nodes with the node computing devices  100  and  201 . The node computing device  208  may be neighbor nodes with the node computing device  205 . The node computing device  209  may be neighbor nodes with the node computing devices  100 ,  201 ,  210 , and  211 . The node computing device  210  may be neighbor nodes with the node computing devices  206 ,  209  and  212 . The node computing device  211  may be neighbor nodes with the node computing devices  209 ,  213 , and  214 . The node computing device  212  may be neighbor nodes with the node computing devices  210 ,  214 , and  215 . The node computing device  213  may be neighbor nodes with the node computing device  211 . The node computing device  214  may be neighbor nodes with the node computing devices  211  and  212 . The node computing device  215  may be neighbor nodes with the node computing devices  212  and  216 . The node computing device  216  may be neighbor nodes with the node computing devices  212  and  215 . 
       FIG.  3 A  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. Each of the node computing devices  100 ,  201 ,  202 ,  203 ,  204 ,  205 ,  206 ,  207 ,  208 ,  209 ,  210 ,  211 ,  212 ,  213 ,  214 ,  215 , and  216  in the network may store a peer table. Each peer table may include a listing of addresses of neighbor nodes and unique identifiers for the neighbor nodes. 
     The node computing device  100  may store the peer table  142  in the storage  140 . The peer table  142  may include addresses and unique identifiers for the node computing devices  207  and  209 , which may be the neighbor nodes of the node computing device  100 . 
     The node computing device  201  may store a peer table  302  in a storage  301 . The peer table  302  may include an address and unique identifier for the node computing device  207 , which may be the neighbor node of the node computing device  201 . 
     The node computing device  202  may store a peer table  304  in a storage  303 . The peer table  304  may include addresses and unique identifiers for the node computing devices  203  and  205 , which may be the neighbor nodes of the node computing device  202 . 
     The node computing device  203  may store a peer table  306  in a storage  305 . The peer table  306  may include addresses and unique identifiers for the node computing devices  202  and  205 , which may be the neighbor nodes of the node computing device  203 . 
     The node computing device  204  may store a peer table  308  in a storage  307 . The peer table  308  may include an address and unique identifier for the node computing device  206 , which may be the neighbor node of the node computing device  204 . 
     The node computing device  205  may store a peer table  310  in a storage  309 . The peer table  310  may include addresses and unique identifiers for the node computing devices  202 ,  203 ,  207  and  208 , which may be the neighbor nodes of the node computing device  205 . 
     The node computing device  206  may store a peer table  312  in a storage  311 . The peer table  312  may include addresses and unique identifiers for the node computing devices  204  and  210 , which may be the neighbor nodes of the node computing device  206 . 
     The node computing device  207  may store a peer table  314  in a storage  313 . The peer table  314  may include addresses and unique identifiers for the node computing devices  100  and  201 , which may be the neighbor nodes of the node computing device  207 . 
     The node computing device  208  may store a peer table  316  in a storage  315 . The peer table  316  may include an address and unique identifier for the node computing device  205 , which may be the neighbor node of the node computing device  208 . 
     The node computing device  209  may store a peer table  318  in a storage  317 . The peer table  318  may include addresses and unique identifiers for the node computing devices  100 ,  201 ,  210 , and  211 , which may be the neighbor nodes of the node computing device  209 . 
     The node computing device  210  may store a peer table  320  in a storage  319 . The peer table  320  may include addresses and unique identifiers for the node computing devices  206 ,  209 , and  212 , which may be the neighbor nodes of the node computing device  210 . 
     The node computing device  211  may store a peer table  322  in a storage  321 . The peer table  322  may include addresses and unique identifiers for the node computing devices  209 ,  213 , and  214 , which may be the neighbor nodes of the node computing device  211 . 
     The node computing device  212  may store a peer table  324  in a storage  323 . The peer table  324  may include addresses and unique identifiers for the node computing devices  210 ,  214 , and  215 , which may be the neighbor nodes of the node computing device  212 . 
     The node computing device  213  may store a peer table  326  in a storage  325 . The peer table  326  may include an address and unique identifier for the node computing device  211 , which may be the neighbor node of the node computing device  213 . 
     The node computing device  214  may store a peer table  328  in a storage  327 . The peer table  328  may include addresses and unique identifiers for the node computing devices  211  and  212 , which may be the neighbor nodes of the node computing device  214 . 
     The node computing device  215  may store a peer table  330  in a storage  329 . The peer table  330  may include addresses and unique identifiers for the node computing devices  212  and  215 , which may be the neighbor nodes of the node computing device  215 . 
     The node computing device  216  may store a peer table  332  in a storage  331 . The peer table  332  may include addresses and unique identifiers for the node computing devices  212  and  215 , which may be the neighbor nodes of the node computing device  216 . 
     The peer tables may also include data about a neighbor node that may indicate which other nodes in the network may be reachable through the neighbor node. For example, an entry for a neighbor node in a peer table may include an IP subnet mask indicating portions of the internet that may be reachable from the neighbor node. Other network types may also use hierarchical data structures as addresses of a node computing devices, allowing for subnet masks. For example, the address of a node computing device for a financial institution may have a hierarchical structure of global region, country within that region, state or territory within that country, city within the state or territory, and specific financial institution within that city. For example, NA.US.CA.SF.GB may be the address of a node computing device for Generic Bank (GB) located in San Francisco (SF), California (CA), the United States (US), North America (NA). An entry in a peer table for a neighbor node may include a subnet mask of NA.US.*, which may indicate that the neighbor node is capable of reaching the node computing device for any financial institution located in the United States. An entry may include multiple subnet masks. This may allow a node computing device to determine whether it is useful to send a notification to a neighbor node. For example, if then entry for a neighbor node only includes NA.US.*, that neighbor node may not be useful when the destination node computing device is located in France. 
       FIG.  4 A  shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. The node computing device  100  may wish to send a message to the node computing device  214 . The node computing device  100  may send a notification to its neighbor nodes, node computing devices  207  and  209 . The node computing device may create separate forward stacks of identifiers with the unique identifiers from the peer table  142  for the node computing devices  207  and  209 . The forward stack of identifiers with the unique identifier for the node computing device  207  may be sent to the node computing device  207 . The forward stack of identifiers with the unique identifier for the node computing device  209  may be sent to the node computing device  209 . 
       FIG.  4 B  shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. The node computing device  207  may receive the notification and the forward stack of identifiers with the unique identifier for the node computing device  207  from the node computing device  100 , and may send the notification to its neighbor nodes from which it did not receive the notification, the node computing devices  201  and  205 . The node computing device  207  may create separate forward stacks of identifiers, starting with the forward stack of identifiers received from the node computing device  100 , with the unique identifiers from the peer table  314  for the node computing devices  201  and  205 . The forward stack of identifiers with the unique identifiers for the node computing devices  201  and  207  may be sent to the node computing device  201 . The forward stack of identifiers with the unique identifier for the node computing device  205  and  207  may be sent to the node computing device  205 . 
     The node computing device  209  may receive the notification and the forward stack of identifiers with the unique identifier for the node computing device  209  from the node computing device  100 , and may send the notification to its neighbor nodes from which it did not receive the notification, the node computing devices  210  and  211 . The node computing device  209  may create separate forward stacks of identifiers, starting with the forward stack of identifiers received from the node computing device  100 , with the unique identifiers from the peer table  318  for the node computing devices  210  and  211 . The forward stack of identifiers with the unique identifiers for the node computing devices  210  and  209  may be sent to the node computing device  210 . The forward stack of identifiers with the unique identifiers for the node computing devices  211  and  209  may be sent to the node computing device  211 . 
       FIG.  4 C  shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. The node computing device  201  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  201  and  207  from the node computing device  207 . The peer table  302  in the storage  301  of the node computing device  201  may list the node computing device  207  as the only neighbor node to the node computing device  201 . The node computing device  201  may detect a circular route and send a failure message to the node computing device  100 , indicating that the route has failed. The forward stack of identifiers may not be returned to the node computing device  100 . 
     The node computing device  205  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  205  and  207  from the node computing device  207  and may send the notification to its neighbor nodes from which it did not receive the notification, the node computing devices  202 ,  203 , and  208 . The node computing device  205  may create separate forward stacks of identifiers, starting with the forward stack of identifiers received from the node computing device  207 , with the unique identifiers from the peer table  310  for the node computing devices  202 ,  203 , and  208 . The forward stack of identifiers with the unique identifiers for the node computing devices  202 ,  205 , and  207  may be sent to the node computing device  202 . The forward stack of identifiers with the unique identifiers for the node computing devices  203 ,  205 , and  207  may be sent to the node computing device  203 . The forward stack of identifiers with the unique identifiers for the node computing devices  208 ,  205 , and  207  may be sent to the node computing device  208 . 
     The node computing device  210  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  210  and  209  from the node computing device  209  and may send the notification to its neighbor nodes from which it did not receive the notification, the node computing devices  206  and  212 . The node computing device  210  may create separate forward stacks of identifiers, starting with the forward stack of identifiers received from the node computing device  207 , with the unique identifiers from the peer table  320  for the node computing devices  206  and  212 . The forward stack of identifiers with the unique identifiers for the node computing devices  206 ,  210 , and  209  may be sent to the node computing device  206 . The forward stack of identifiers with the unique identifiers for the node computing devices  212 ,  210 , and  209  may be sent to the node computing device  212 . 
     The node computing device  211  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  211  and  209  from the node computing device  209 . The node computing device  211  may determine, based on the peer table  322 , that the destination node, the node computing device  214 , is a neighbor node of the node computing device  211 . The node computing device  211  may add the unique identifier for the node computing device  214  from the peer table  322  to the forward stack of identifiers received from the node computing device  209 . This forward stack of identifiers, including unique identifiers for the node computing devices  214 ,  211 , and  209 , may include a complete route from the originator node, the node computing device  100 , to the destination node, the node computing device  214 . The forward stack of identifiers may be returned to the node computing device  100  through the node computing devices  211  and  209 . The node computing device  211  may not need to send the notification to the node computing device  213 . 
       FIG.  4 D  shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. The node computing device  202  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  202 ,  205  and  207  from the node computing device  205  and may send the notification to its neighbor node from which it did not receive the notification, the node computing device  203 . The node computing device  202  may create a forward stack of identifiers, starting with the forward stack of identifiers received from the node computing device  205 , with the unique identifiers from the peer table  204  for the node computing device  203 . The forward stack of identifiers with the unique identifiers for the node computing devices  203 ,  202 ,  205 , and  207  may be sent to the node computing device  203 . 
     The node computing device  203  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  203 ,  205  and  207  from the node computing device  205  and may send the notification to its neighbor node from which it did not receive the notification, the node computing device  202 . The node computing device  203  may create a forward stack of identifiers, starting with the forward stack of identifiers received from the node computing device  205 , with the unique identifiers from the peer table  206  for the node computing device  202 . The forward stack of identifiers with the unique identifiers for the node computing devices  202 ,  203 ,  205 , and  207  may be sent to the node computing device  202 . 
     The node computing device  206  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  206 ,  210 , and  209  from the node computing device  210  and may send the notification to its neighbor node from which it did not receive the notification, the node computing device  204 . The node computing device  206  may create a forward stack of identifiers, starting with the forward stack of identifiers received from the node computing device  210 , with the unique identifiers from the peer table  312  for the node computing device  204 . The forward stack of identifiers with the unique identifiers for the node computing devices  204 ,  206 ,  210 , and  209  may be sent to the node computing device  204 . 
     The node computing device  208  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  208 ,  205 , and  207  from the node computing device  205 . The peer table  316  in the storage  315  of the node computing device  208  may list the node computing device  205  as the only neighbor node to the node computing device  208 . The node computing device  208  may detect a circular route and send a failure message to the node computing device  100 , indicating that the route has failed. The forward stack of identifiers may not be returned to the node computing device  100 . 
     The node computing device  212  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  212 ,  210 , and  209  from the node computing device  210 . The node computing device  212  may determine, based on the peer table  324 , that the destination node, the node computing device  214 , is a neighbor node of the node computing device  212 . The node computing device  212  may add the unique identifier for the node computing device  214  from the peer table  324  to the forward stack of identifiers received from the node computing device  210 . This forward stack of identifiers, including unique identifiers for the node computing devices  214 ,  212 ,  210 , and  209 , may include a complete route from the originator node, the node computing device  100 , to the destination node, the node computing device  214 . The forward stack of identifiers may be returned to the node computing device  100  through the node computing devices  212 ,  210 , and  209 . The node computing device  212  may not need to send the notification to the node computing devices  215  and  216 . 
       FIG.  4 E  shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. The node computing device  202  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  202 ,  203 ,  205  and  207  from the node computing device  203  and may send the notification to its neighbor node from which it did not receive the notification, the node computing device  205 . The node computing device  202  may create a forward stack of identifiers, starting with the forward stack of identifiers received from the node computing device  203 , with the unique identifiers from the peer table  204  for the node computing device  205 . The forward stack of identifiers with the unique identifiers for the node computing devices  205 ,  202 ,  203 ,  205 , and  207  may be sent to the node computing device  205 . 
     The node computing device  203  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  203 ,  202 ,  205  and  207  from the node computing device  203  and may send the notification to its neighbor node from which it did not receive the notification, the node computing device  205 . The node computing device  203  may create a forward stack of identifiers, starting with the forward stack of identifiers received from the node computing device  202 , with the unique identifiers from the peer table  206  for the node computing device  205 . The forward stack of identifiers with the unique identifiers for the node computing devices  205 ,  203 ,  202 ,  205 , and  207  may be sent to the node computing device  205 . 
     The node computing device  204  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  204 ,  206 ,  210 , and  209  from the node computing device  206 . The peer table  308  in the storage  307  of the node computing device  204  may list the node computing device  206  as the only neighbor node to the node computing device  204 . The node computing device  204  may detect a circular route and send a failure message to the node computing device  100 , indicating that the route has failed. The forward stack of identifiers may not be returned to the node computing device  100 . 
       FIG.  4 F  shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. The node computing device  205  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  205 ,  202 ,  203 ,  205  and  207  from the node computing device  202 . The node computing device  205  may detect a circular route and send a failure message to the node computing device  100 , indicating that the route has failed. The circular route may be based on, for example, an identifier associated with the open connection between the node computing device  205  and the node computing device  203  and included in the forward stack of identifiers or in the notification sent to the node computing device  203 . The forward stack of identifiers may not be returned to the node computing device  100 . 
     The node computing device  205  may receive the notification and the forward stack of identifiers with the unique identifiers for the node computing devices  205 ,  203 ,  202 ,  205  and  207  from the node computing device  203 . The node computing device  205  may detect a circular route and send a failure message to the node computing device  100 , indicating that the route has failed. The circular route may be based on, for example, an identifier associated with the open connection between the node computing device  205  and the node computing device  202  and included in the forward stack of identifiers or in the notification sent to the node computing device  202 . The forward stack of identifiers may not be returned to the node computing device  100 . 
       FIG.  5 A  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. A notification  550  may indicate the intent of the node computing device  100  to send a message to the node computing device  214 . This may start pathfinding through the network. The node computing device  100 , when sending the notification  550  to its neighbor nodes, may also send forward stacks of identifiers to the neighbor nodes. For example, the node computing device  100  may create the forward stack  510  using the unique identifier from the peer table  142  for the node computing device  209 . The communications controller  110  of the node computing device  100  may use the address for the node computing device  209  from the peer table  142  to send the forward stack  510  and the notification  550  to the node computing device  209 , where it may be received by a communications controller  520  of the node computing device  209 . 
       FIG.  5 B  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. The node computing device  209  may receive the notification  550  and determine, based on the peer table  318 , that it is not a neighbor node of the destination node, the node computing device  214 . The node computing device  209  may send the notification  550  received from the node computing device  100  to its neighbor nodes from which it did not receive the notification, and may also send forward stacks of identifiers to the neighbor nodes. For example, the node computing device  209  may add the unique identifier from the peer table  318  for the node computing device  211  to the forward stack  510 . The communications controller  520  of the node computing device  209  may use the address for the node computing device  211  from the peer table  318  to send the forward stack  510  and the notification  550  to the node computing device  211 , where it may be received by a communications controller  530  of the node computing device  211 . 
       FIG.  5 C  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. The node computing device  211  may receive the notification  550  and determine based on the peer table  322  that it is a neighbor node of the destination node, the node computing device  214 . The node computing device  211  may not send the notification  550  to its neighbor nodes from which it did not receive the notification, and may instead complete the route in the forward stack  510 . For example, the node computing device  211  may add the unique identifier from the peer table  322  for the node computing device  214  to the forward stack  510 . This may result in the forward stack  510  including a complete route from the node computing device  100  to the node computing device  214  using unique identifiers which may only be resolvable to addresses by the node computing devices that added the unique identifiers to the forward stack  510 . The node computing device  211  may unable to resolve the other unique identifiers already in the forward stack  510 , although it may know that the unique identifier two places in front of the unique identifier added by the node computing device  211  identifies the node computing device  209 . The identity of the originator node, the node computing device  100 , may remain obscured to the node computing device  211 . The communications controller  530  of the node computing device  211  may use an open connection with the node computing device  209  to send the forward stack  510  back to the node computing device  209 . The node computing device  209  may use an open connection with the node computing device  100  to send the forward stack  510  back to the node computing device  100 . 
       FIG.  6    shows an example system suitable for obscured routing according to an implementation of the disclosed subject matter. The node computing device  100  may receive forward stacks of identifiers with completed routes to the node computing device  214  in response to the notification, for example, the notification  550 , sent out by the node computing device  100  to its neighbor nodes. The node computing device  100  may be the originator node and the node computing device  214  may be the destination node. The node computing device  100  may choose a route from a forward stack of identifiers to use to send a message to the node computing device  214 . The forward stacks of identifiers may be, for example, the forward stack  510 , and a forward stack of identifiers that includes the unique identifiers for the node computing devices  209 ,  210 ,  212 , and  214 . 
     The node computing device  100  may use the route from the forward stack  510 . The message sent by the node computing device  100  may be routed through the node computing device  209  and the node computing device  211  before reaching the destination node, the node computing device  214 . 
       FIG.  7 A  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. The node computing device  100  may use the route in the forward stack  510  to send a message  700  to the node computing device  214 . The message  700  may be any suitable data for transmission over a network. The node computing device  100  may read the first unique identifier from the forward stack  510 , which may be the unique identifier that was added to the forward stack  510  by the node computing device  100 . The first unique identifier may be at the bottom of the forward stack  510 , which may be, for example, a first-in-first-out queue. The node computing device  100  may look-up the unique identifier read from the forward stack  510  in the peer table  142 . This may resolve the unique identifier to an address that can be used to establish a connection with the next node computing device in the route in the forward stack  510 . For example, the unique identifier “h33f8e71” read from the forward stack  510  may be resolved to the address “255.209”, which may be the address in the network for the node computing device  209 . The unique identifier read from the forward stack  510  may be removed from the forward stack  510 , for example, popped off a stack or exited from a queue. 
     The node computing device  100  may be unable to resolve the remaining unique identifiers in the forward stack  510 , as the unique identifiers were not added to the forward stack  510  by the node computing device  100  and are therefore not listed in the peer table  142 . However, the node computing device  100  may know that the last unique identifier identifies the node computing device  214  because the node computing device  100  set the node computing device  214  as the destination node. The identity of the third node in the route may be entirely obscured to the node computing device  100 . If the route included additional nodes, for example, 6 nodes, the node computing device  100  may still only be able to identify its neighbor node in the route and the destination node in the route, with, for example, the other 3 nodes remaining obscured to the node computing device  100 . 
     The communications controller  110  of the node computing device  100  may use the address for the node computing device  209  to send the forward stack  510  and the message  700  to the node computing device  209 , where it may be received by a communications controller  520  of the node computing device  209 . 
     The node computing device  100  may store the forward stack  510  in the cached routes  152 . The forward stack  510  may be stored before removing the unique identifier that was read from the forward stack  510 . 
       FIG.  7 B  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. The node computing device  209  may use the route in the forward stack  510  to send the message  700 , received from the node computing device  100 , to the next node in the route in the forward stack  510 . The node computing device  209  may read the first unique identifier from the forward stack  510 , which may be the unique identifier that was added to the forward stack  510  by the node computing device  209 . The first unique identifier may be at the bottom of the forward stack  510 , which may be a first-in-first-out queue. The node computing device  209  may look-up the unique identifier read from the forward stack  510  in the peer table  318 . This may resolve the unique identifier to an address that can be used to establish a connection with the next node computing device in the route in the forward stack  510 . For example, the unique identifier “rd10m64c” read from the forward stack  510  may be resolved to the address “255.211”, which may be the address in the network for the node computing device  211 . The unique identifier read from the forward stack  510  may be removed from the forward stack  510 , for example, popped off a stack or exited from a queue. 
     The node computing device  209  may be unable to resolve the remaining unique identifier in the forward stack  510 , as the unique identifier was not added to the forward stack  510  by the node computing device  100  and are therefore not listed in the peer table  318 . The node computing device  209  may know that the remaining unique identifier identifies the node computing device  214  if the node computing device  209  is able to associate the forward stack  510  with the notification  550 . Node computing devices that are part of the network may be configured to not store data on notifications so that they may be unable to identify nodes in routes that are not their neighbor nodes. If the route included additional nodes, for example, 6 nodes, the node computing device  209  may only be able to identify its neighbor nodes in the route and possibly the destination node in the route, with, for example, the other 2 nodes remaining obscured to the node computing device  209 . 
     The communications controller  520  of the node computing device  209  may use the address for the node computing device  211  to send the forward stack  510  and the message  700  to the node computing device  211 , where it may be received by a communications controller  530  of the node computing device  211 . 
     If asynchronous messaging is being used, the node computing device  209  may create a return stack  710 . The return stack  710  may be a return stack of identifiers that may be used by the destination node, the node computing device  214 , to send messages back to the node computing device  100 . The node computing device  209  may look up the unique identifier for the node from which it received the message  700 , the node computing device  100 , in the peer table  318 . The unique identifier may then be added to the return stack  710 . The return stack  710  may be sent to the next node in the route in the forward stack  510 , for example, the node computing device  211 , along with the message  700  and the forward stack  510 . 
       FIG.  7 C  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. The node computing device  211  may use the route in the forward stack  510  to send the message  700 , received from the node computing device  209 , to the next node in the route in the forward stack  510 . The node computing device  211  may read the remaining unique identifier from the forward stack  510 , which may be the unique identifier that was added to the forward stack  510  by the node computing device  211 . The node computing device  211  may look-up the unique identifier read from the forward stack  510  in the peer table  322 . This may resolve the unique identifier to an address that can be used to establish a connection with the next node computing device in the route in the forward stack  510 . For example, the unique identifier “gnwe6rou” read from the forward stack  510  may be resolved to the address “255.214”, which may be the address in the network for the node computing device  214 . The unique identifier read from the forward stack  510  may be removed from the forward stack  510 , for example, popped off a stack or exited from a queue. 
     The node computing device  211  may receive the forward stack  510  with only one unique identifier in it. This may prevent the node computing device  211  from identify any node computing device in the route of the forward stack  510  that is not a neighbor node of the node computing device  211 . For example, the node computing device  211  may not be aware that the node computing device  100  is part of the route in the forward stack  510 . If the route included additional nodes, for example, 6 nodes, the node computing device  209  may only be able to identify its neighbor nodes in the route, which include the destination node, with, for example, the other 3 nodes remaining obscured to the node computing device  211 . 
     The communications controller  530  of the node computing device  211  may use the address for the node computing device  214  to send the the message  700  to the node computing device  214 , where it may be received by a communications controller  720  of the node computing device  214 . 
     If asynchronous messaging is being used, the node computing device  211  may add a unique identifier to the return stack  710 . The node computing device  211  may look up the unique identifier for the node from which it received the message  700 , the node computing device  209 , in the peer table  322 . The unique identifier may then be added to the return stack  710 . The return stack  710  may be sent to the next node in the route in the forward stack  510 , for example, the node computing device  214 , along with the message  700 . 
       FIG.  7 D  shows an example arrangement suitable for obscured routing according to an implementation of the disclosed subject matter. The node computing device  214  may receive the message  700 . As the destination node, the node computing device  214  may not receive a forward stack of identifiers. All nodes in the route may be obscure to the node computing device  214  except for its neighbor node in the route. In some implementations, the node computing device  214  may be able to identify the node computing device  100  based on data included in the message  700 . 
     If synchronous messaging is used, the node computing device  214  may be able to send a message to the node computing device  211  through an open connection. The node computing device  211  may send this message back to the node computing device  209 , which may send the message back to the node computing device  100 , through open connections. 
     If asynchronous messaging is being used, the node computing device  214  may add a unique identifier to the return stack  710 . The node computing device  214  may look up the unique identifier for the node from which it received the message  700 , the node computing device  211 , in the peer table  328 . The unique identifier may then be added to the return stack  710 . The node computing device  214  may send a message back to the node computing device  100  using the return stack  710 . The return stack  710  may be used to send a message to the node computing device  100  in the same manner as the forward stack  510  was used to send the message  700  to the node computing device  214 . 
       FIG.  8    shows an example procedure suitable for obscured routing according to an implementation of the disclosed subject matter. At  800 , forward stacks of identifiers may be created. A node computing device that intends to send a message to another node computing device in a network may create forward stacks of identifiers for each of its neighbor nodes. For example, the node computing device  100  may create forward stacks of identifiers for each of the node computing devices  207  and  209  using unique identifiers from the peer table  142 . 
     At  802 , notifications and forward stacks of identifiers may be sent to neighbor nodes. The node computing device that intends to send a message to another node computing device in the network may send notification of this intent to each of its neighbor nodes for which it created a forward stack of identifiers, along with the forward stack of identifiers created for that neighbor node. For example, the node computing device  100  may send a notification and a forward stack of identifiers with the unique identifier for the node computing device  207  to the node computing device  207 , and may send a notification and a forward stack of identifiers with the unique identifier for the node computing device  209  to the node computing device  209 . The notification may include an indication of the destination node for the message the node computing device  100  intends to send. 
     At  804 , forward stacks of identifiers may be received. The node computing device that sent out the notifications may receive forward stacks of identifiers from its neighbor nodes. The forward stacks of identifiers may include routes through the network to the destination node. For example, the node computing device  100  may receive forward stacks of identifiers, such as the forward stack  510 , from the node computing devices  207  and  209 . The node computing device  100  may receive any number of forward stacks of identifiers, and each forward stack of identifiers may include a complete route to the destination node. The routes may be specified using unique identifiers from peer tables of the node computing devices on the route. 
     At  806 , a route may be chosen from the forward stacks of identifiers. The node computing device that received the forward stacks of identifiers with complete routes may choose a route. For example, the node computing device  100  may choose a route to the destination node from among the forward stacks of identifiers received from the node computing devices  207  and  209 . The node computing device  100  may use any suitable criteria to choose a route. For example, the node computing device  100  may choose a route based on which neighbor node of the node computing device  100  the route uses. The node computing device  100  may choose a route based on the number of nodes in the route, as indicated by the number of unique identifiers in the forward stack of identifiers for the route. The node computing device  100  may choose a route based on a cost associated with the route. The cost of a route may be included with a forward stack of identifiers received by the node computing device  100 , or the node computing device  100  may send a quote request to the route in a forward stack of identifiers, and may receive the cost of the route in return. The cost may be itemized by each node computing device in the route, or may be a total cost. 
     At  808 , the first unique identifier from the forward stack of identifiers for the chosen route may be resolved to an address. The node computing device that has chosen a route may look up the first unique identifier in the route in its peer table to resolve the unique identifier to an address. For example, the node computing device  100  may look up the first unique identifier in a forward stack of identifiers for the chosen identifiers in the peer table  142 , resolving the unique identifier to an address of one of the neighbor nodes of the node computing device  100 . For example, the unique identifier may resolve to the address for either node computing device  207  or the node computing device  209 . 
     At  810 , the first unique identifier may be removed from the forward stack of identifiers for the route. The node computing device that looked up the first unique identifier and resolved it to an address may remove that unique identifier from the forward stack of identifiers. For example, the node computing device  100  may remove the unique identifier looked up in the peer table  142  from the forward stack of identifiers for the chosen route, for example, the forward stack  510 . The unique identifier that is removed from the forward stack of identifiers may be the unique identifier that identifiers that next node computing device in the route. 
     At  812 , the message and forward stack of identifiers may be sent to the address. The node computing device that looked up the first unique identifier and resolved it to an address may remove that unique identifier from the forward stack of identifiers. For example, the node computing device  100  may send the message, such as the message  700 , to the node computing device at the address that the looked up unique identifier from the forward stack of identifiers was resolved to. The node computing device at the address may be, for example, the node computing device  207  or  209 . The forward stack of identifiers, for example, the forward stack  510 , with the looked up unique identifier removed, may be sent to the node computing device at the address along with message. 
       FIG.  9    shows an example procedure suitable for obscured routing according to an implementation of the disclosed subject matter. At  900 , a notification and forward stack of identifiers may be received. A node computing device may receive a notification and a forward stack of identifiers from one of its neighbor nodes in the network. For example, the node computing device  211  may receive a notification and a forward stack of identifiers from the node computing device  209 . The notification may include an indication of the destination node for the message the node computing device that originally sent out the notification intends to send. The forward stack of identifiers may include unique identifiers for the node computing device  209  and for other node computing devices that the notification passed through before being received by the node computing device  209 . 
     At  902 , a peer table may be checked for the address of a destination node. A node computing device the receives a notification may check its peer table for the address of the destination node indicated in the notification. For example, the notification received by the node computing device  211  may indicate the node computing device  214  is the destination node. The node computing device  211  may check the peer table  322  to determine whether it includes the address for the node computing device  214 . 
     At  904 , if the address for the destination node is found in the peer table, flow may proceed to  906 . Otherwise, flow may proceed to  910 . If the address for the destination node included in a notification is found in the peer table of a node computing device that received the notification, that node computing device may be neighbor to the destination node. If the address for the destination node included in a notification is not found in the peer table of a node computing device that received the notification, that node computing device may not be a neighbor to the destination node. 
     At  906 , a unique identifier for the destination node may be added to the forward stack of identifiers. A node computing device that finds the address for a destination node from a received notification in its peer table may be a neighbor to the destination node, and may be able to complete the route in the forward stack of identifiers by adding the unique identifier for the destination node from its peer table. For example, the node computing device  211  may determine that the peer table  322  includes the address for the destination node, the node computing device  214 , indicated in the notification received by the node computing device  211  from the node computing device  209 . The node computing device  211  may add the unique identifier for the node computing device  214  from the peer table  322  to the forward stack of identifiers. This may complete the route in the forward stack of identifiers from the originator node to the destination node. 
     At  908 , a forward stack of identifiers may be returned. A node computing device that has added a unique identifier for the destination node to a forward stack of identifiers may return the forward stack of identifiers to the node computing device from which the notification and forward stack of identifiers was received. For example, the node computing device  211  may return the forward stack of identifiers to the node computing device  209 , from which the node computing device  211  received the notification and forward stack of identifiers. The forward stack of identifiers may be returned over an open connection established between the node computing device  209  and the node computing device  211  when the node computing device  209  sent the notification and forward stack of identifiers to the node computing device  211 . 
     At  910 , if a circular route is detected, flow may proceed to  912 . Otherwise, flow may proceed to  914 . A node computing device that receives a notification and determines that it is not a neighbor of the destination node indicated in the notification may check for a circular route. A circular route may be detected when, for example, the node computing device determines that the only neighbor node computing device the node computing device could send the notification and stack of forward identifiers to is the neighbor node computing device from which the node computing device just received the notification and stack of identifiers. A circular route may also be detected when, for example, the node computing device determines that it has already received the notification and forward stack of identifiers, and added a unique identifier to the forward stack of identifiers, previously. 
     At  912 , a failure message may be returned. A node computing device that detects a circular route may determine that the route in the in the forward stack of identifiers has failed, and may return a failure message to the node computing device from which it received the notification and forward stack of identifiers. For example, the node computing device  201 , on receiving a notification and forward stack of identifiers from the node computing device  207 , may detect a circular route due to the node computing device  207  being the only neighbor node to which the node computing device  201  could send the notification and forward stack of identifiers. The node computing device  201  may return a failure message to the node computing device  207 . 
     At  914 , forward stacks of identifiers may be created for neighbor nodes. A node computing device that is not a neighbor node of the destination node may create forward stacks of identifiers for its neighbor nodes by adding unique identifiers for its neighbor nodes to the received forward stack of identifiers. For example, the node computing device  210 , on receiving a notification and forward stack of identifiers from the node computing device  209 , may determine that is not a neighbor node of the destination indicated in the notification. The node computing device  210  may use the forward stack of identifiers to create forward stacks of identifiers to send to the neighbor node from which it did not receive the notification, the node computing devices  206  and  212 . The node computing device  210  may look-up the unique identifier for the node computing device  206  in the peer table  320  and add that unique identifier to the received forward stack of identifiers to create a forward stack of identifiers to be sent to the node computing device  206 . The node computing device  210  may look-up the unique identifier for the node computing device  212  in the peer table  320  and add that unique identifier to the received forward stack of identifiers to create a forward stack of identifiers to be sent to the node computing device  212 . The forward stacks of identifiers may be separate, and each may have only one unique identifier added to it by the node computing device  210 . 
     At  916 , the notification and forward stacks of identifiers may be sent to neighbor nodes. A node computing device which has created forward stacks of identifiers for its neighbor nodes may send those forward stacks of identifiers, and the received notification, to the neighbor nodes. For example, the node computing device  210  may send the notification received from the node computing device  209  and the forward stack of identifiers to which it added the unique identifier for the node computing device  206  to the node computing device  206 . The node computing device may also send the notification received from the node computing device  209  and the forward stack of identifiers to which it added the unique identifier for the node computing device  212  to the node computing device  212 . 
     At  918 , forward stacks of identifiers and failure messages may be received. A node computing device may maintain an open connection with the neighbor nodes to which it sent the notification and forward stacks of identifiers, and may receive forward stacks of identifiers or failure messages from each of those neighbor nodes. For example, the node computing device  210  may receive a forward stack of identifiers from the node computing device  212  through the open connection that was used by the node computing device  210  to send the notification and forward stack of identifiers to the node computing device  212 . This may indicate that the forward stack of identifiers returned by the node computing device  212  includes a complete route to the destination node. The node computing device  210  may receive a failure message from the node computing device  206 . This may indicate that a circular route was detected, or a maximum number of nodes was reached, either at or beyond the node computing device  206 . 
     At  920 , forward stacks of identifiers and failure messages may be returned. A node computing device that receives a forward stack of identifiers returned through an open connection may return that forward stack of identifiers to the neighbor node computing device from which it was received. A node computing device that receives a failure message may return the failure message to the neighbor node computing device from which the forward stack of identifiers that included the route that has now failed was received. For example, the node computing device  210  may return both the forward stack of identifiers returned by the node computing device  212  and the failure message returned by the node computing device  206  to the node computing device  209 . 
       FIG.  10 A  shows an example procedure suitable for obscured routing according to an implementation of the disclosed subject matter. At  1000 , a message may be received. A node computing device may receive a message that is being sent through a network. For example, the node computing device  211  may receive the message  700  from the node computing device  209 . 
     At  1002 , if a forward stack of identifiers is received, flow may proceed  1004 . Otherwise, flow may proceed to  1014 . For example, if a node computing device that receives a message also receives a forward stack of identifiers, that node computing may not be the destination node for the message and may proceed to pass the message to the next node computing device in the route as indicated in the forward stack of identifiers. If a node computing device does not receive a forward stack of identifiers along with a message, the node computing device may be the destination node for the message. 
     At  1004 , a first unique identifier may be resolved to an address using a peer table. A node computing device that receives a message and a forward stack of identifiers may determine which node computing device to send the message to by looking up the first unique identifier in the forward stack of identifiers in its peer table to obtain an address. For example, the node computing device  211  may look up the unique identifier “gnwe6rou” from the forward stack  510  in the peer table  322 . The unique identifier may resolve to the address 255.214, which may be the address of the node computing device  214 . The unique identifier looked up by a node computing device from a forward stack of identifiers may be a unique identifier that was previously added to that forward stack of identifiers by the node computing device. 
     At  1006 , the first unique identifier may be removed from the forward stack of identifiers. After a node computing device resolves the first unique identifier from a forward stack of identifiers to an address, the node computing device may remove the first unique identifier from the forward stack of identifiers. For example, the node computing device  211 , after looking up the unique identifier “gnwe6rou” from the forward stack  510  in the peer table  322 , may remove the unique identifier “gnwe6rou” from the forward stack  510 . 
     At  1008 , if the forward stack of identifiers is empty, flow may proceed to  1012 . Otherwise, flow may proceed to  1010 . If the forward stack of identifiers is empty after the node computing device removes the looked-up unique identifier, the address the looked-up unique identifier resolved to may be the destination node for the message. Otherwise, the next node computing device in the route may need the forward stack of identifiers to determine where it should send the message. 
     At  1010 , the forward stack of identifiers may be sent to the address. The node computing device may send the forward stack of identifiers, having removed the looked-up unique identifier, to the address that the looked-up unique identifier resolved to. For example, the node computing device  209  may send the forward stack  510  to the node computing device  211  after removing the unique identifier that the node computing device  209  resolved to the address of the node computing device  211  using the peer table  318 . 
     At  1012 , the message may be sent to the address. A node computing device that is not the destination node for a message may send the message to the address of the next node computing device in the route as determined by looking up the first unique identifier in the peer table. For example, the node computing device  209  may send the message  700  to the node computing device  211 . As another example, the node computing device  211  may send the message  700  to the node computing device  214  while not sending the forward stack  510 , which may now be empty, indicating that the node computing device  214  is the destination node. The message may be passed in unaltered form between nodes, or nodes may make changes to the message. For example, a message received by a node computing device may cause that node computing device to perform some operation. The node computing device may then alter the message to include proof that the operation was performed. The node computing device may also alter the message to include instructions for an operation to be performed by the next node computing device that receives the message, in accordance with instructions or rules already included in the message. 
     At  1014 , a reply to a received message may be sent. A node computing device that receives a message and no forward stack of identifiers may be the destination node for the message, and may choose to reply to the message over an open connection to the node computing device that sent the message. The reply may be passed back the node computing device that was the originator node for the message through open connections between neighbor nodes on the route from the originator node to the destination node. Replying to a received message may be optional for the destination node. 
       FIG.  10 B  shows an example procedure suitable for obscured routing according to an implementation of the disclosed subject matter. At  1016 , if a return stack is received, flow may proceed to  1018 , otherwise flow may proceed to  1020 . A node computing device may receive a return stack of identifiers along with a message received at  1000  when a network uses asynchronous messaging. For example, the node computing device  211  may receive the return stack  710  from the node computing device  209  along with the message  700  when the network uses asynchronous messaging. 
     At  1018 , a unique identifier for a previous node may be added to the return stack of identifiers. A node computing device that receives a return stack of identifiers may look up in its peer table the previous node computing device in the route from which the return stack of identifiers was received. For example, the node computing device  211 , after receiving the return stack  710  from the node computing device  209 , may look up the unique identifier for the node computing device  209  in the peer table  322 . The unique identifier for the node computing device  209  may be added to the return stack  710 . 
     At  1020 , a return stack of identifiers may be created using a unique identifier for a previous node. If a node computing device in a network that uses asynchronous messaging receives a message and a forward stack of identifiers with no return stack of identifiers, the node computing device may need to create the return stack of identifiers using the unique identifier for the previous node from which it received the message and forward stack of identifiers. The previous node may be the originator node for the message. For example, the node computing device  209  may receive the message  700  and the forward stack  510  from the node computing device  100 , but may not receive a return stack of identifiers. The node computing device  209  may create the return stack of identifiers by looking up the unique identifier for the node computing device  100  in the peer table  318  and adding the unique identifier as the first unique identifier in the return stack  710 . 
     At  1022 , the message and the return stack of identifiers may be sent to an address. A node computing device that received a forward stack of identifiers may, after resolving the first unique identifier in the forward stack of identifiers to an address and removing that first unique identifier from the forward stack of identifiers, send both the message and the return stack of identifiers to the address, which may be for the next node computing device in the route. For example, the node computing device  211 , after resolving the unique identifier “gnwe6rou” from the forward stack  510  to the address 255.214 using the peer table  322 , may remove the unique identifier “gnwe6rou” from the forward stack  510  and send the message  700  and the return stack  710  to the node computing device  214 . 
     At  1024 , a reply to a received message may be sent using the return stack of identifiers. A node computing device that receives a message and no forward stack of identifiers may be the destination node for the message, and may choose to reply to the message using a return stack of identifiers. The return stack of identifiers may be used by the destination node in the same manner that the forward stack of identifiers was used by the originator node. The return stack of identifiers may include a route from the destination node back to the originator node, reversing the route the message travelled from the originator node to the destination node. Replying to a received message may be optional for the destination node. 
     Implementations of the presently disclosed subject matter may be implemented in and used with a variety of component and network architectures.  FIG.  11    is an example computer  20  suitable for implementations of the presently disclosed subject matter. The computer  20  includes a bus  21  which interconnects major components of the computer  20 , such as a central processor  24 , a memory  27  (typically RAM, but which may also include ROM, flash RAM, or the like), an input/output controller  28 , a user display  22 , such as a display screen via a display adapter, a user input interface  26 , which may include one or more controllers and associated user input devices such as a keyboard, mouse, and the like, and may be closely coupled to the I/O controller  28 , fixed storage  23 , such as a hard drive, flash storage, Fibre Channel network, SAN device, SCSI device, and the like, and a removable media component  25  operative to control and receive an optical disk, flash drive, and the like. 
     The bus  21  allows data communication between the central processor  24  and the memory  27 , which may include read-only memory (ROM) or flash memory (neither shown), and random access memory (RAM) (not shown), as previously noted. The RAM is generally the main memory into which the operating system and application programs are loaded. The ROM or flash memory can contain, among other code, the Basic Input-Output system (BIOS) which controls basic hardware operation such as the interaction with peripheral components. Applications resident with the computer  20  are generally stored on and accessed via a computer readable medium, such as a hard disk drive (e.g., fixed storage  23 ), an optical drive, floppy disk, or other storage medium  25 . 
     The fixed storage  23  may be integral with the computer  20  or may be separate and accessed through other interfaces. A network interface  29  may provide a direct connection to a remote server via a telephone link, to the Internet via an internet service provider (ISP), or a direct connection to a remote server via a direct network link to the Internet via a POP (point of presence) or other technique. The network interface  29  may provide such connection using wireless techniques, including digital cellular telephone connection, Cellular Digital Packet Data (CDPD) connection, digital satellite data connection, or the like. For example, the network interface  29  may allow the computer to communicate with other computers via one or more local, wide-area, or other networks, as shown in  FIG.  12   . 
     Many other devices or components (not shown) may be connected in a similar manner (e.g., document scanners, digital cameras, and so on). Conversely, all of the components shown in  FIG.  11    need not be present to practice the present disclosure. The components can be interconnected in different ways from that shown. The operation of a computer such as that shown in  FIG.  11    is readily known in the art and is not discussed in detail in this application. Code to implement the present disclosure can be stored in computer-readable storage media such as one or more of the memory  27 , fixed storage  23 , removable media  25 , or on a remote storage location. 
       FIG.  12    shows an example network arrangement according to an implementation of the disclosed subject matter. One or more clients  10 ,  11 , such as local computers, smart phones, tablet computing devices, and the like may connect to other devices via one or more networks  7 . The network may be a local network, wide-area network, the Internet, or any other suitable communication network or networks, and may be implemented on any suitable platform including wired and/or wireless networks. The clients may communicate with one or more servers  13  and/or databases  15 . The devices may be directly accessible by the clients  10 ,  11 , or one or more other devices may provide intermediary access such as where a server  13  provides access to resources stored in a database  15 . The clients  10 ,  11  also may access remote platforms  17  or services provided by remote platforms  17  such as cloud computing arrangements and services. The remote platform  17  may include one or more servers  13  and/or databases  15 . 
     The foregoing description, for purpose of explanation, has been described with reference to specific embodiments. However, the illustrative discussions above are not intended to be exhaustive or to limit embodiments of the disclosed subject matter to the precise forms disclosed. Many modifications and variations are possible in view of the above teachings. The embodiments were chosen and described in order to explain the principles of embodiments of the disclosed subject matter and their practical applications, to thereby enable others skilled in the art to utilize those embodiments as well as various embodiments with various modifications as may be suited to the particular use contemplated.