Re: [MUTE] MUTE 0.4.1 released

[Nate <fi...@fa...>]

This still has the same problems as the proposal I posted a while back
on sending to randomly selected nodes, but Jason pointed out that it
could still flood the network because you can't make sure that 100% of
the time it decreases the "tree branching" on down the line.

In the *static*, perfect world examples it always shows a tree that
slowly decreases in size, but with this method, which *is* random, it
can go either way. And with the real world dynamic nature of the
network, it's even more random.

Take the examples and run them backwards, remember that the network goes
both ways. If it decreased down one *static* path, the same exact
*static* path going the other way through would then increase the
branching.

And to be more clear about this:

If a path you send down has 4 nodes that all happened to choose 2 as a
random number to send to, then your message will flood to at least 8
nodes, and if some of those nodes happen to choose > 1 to send to then
it keeps going, and branching, and going, and branching...

Sometimes it will decrease. Hey, it's random so who knows?

There is no way to dependably control flooding with this method.

You also can't ask the other nodes what they are doing so that you can
"cooperate" and know how to adjust your branching to make sure the
branching does decrease in a certain direction without causing
anonymity concerns.

There also may be a way for a outside party to determine what random
number you have selected by connecting many times to the same node. That
knowledge may lead to other possible attacks.

One other possible problem: In this version it always goes down the
connected node list in order, not randomly.

This is why I picked the GMT time stamp to simply stop the message when
a time limit is reached. Everyone is sync'ed to the same clock, but the
sync comes from many random open public sources.

It's also good to not have a TTL and a message "counter" anymore, these
are always things that could be used as an attack vector.


Some details, notes, comments and the code section that generates the
random number of nodes:

"muteNumNeighborsToSendDropTailsTo" is randomly generated once at start
up, not with every packet to be routed. Would it make a difference in
reducing the branching if it did it at every packet? Not really, it's
still random.

"muteNumNeighborsToSendDropTailsTo" is set at start up but you don't
know how many nodes you are connected to, or are going to be connected
to later on so it could be more than you have and then you will always
send to "ALL" for the entire time the program is running.

In below code, zero nodes to send to will actually send a DROP_TTL
message to "ALL".

// first, flip an unfair coin
if( muteRandomSource->getRandomFloat() <= 0.75f ) {
    muteNumNeighborsToSendDropTailsTo = 0;
    }
else {
    // flip a series of fair coins until we flip "false"

    // increment our neighbor count each time we flip true
    muteNumNeighborsToSendDropTailsTo = 1;

    while( muteRandomSource->getRandomFloat() <= 0.5f ) {
        muteNumNeighborsToSendDropTailsTo++;
        }
    }