Over the passed few days I've been thinking about the possibility of sending bits over "probabilistic" connections.

I've already put together a crude working prototype, and although it does "work", I'm wondering just how secure it is. I can't seem to think of any way that the data could be compromised in transit, but like I said, I just don't know if I've looked at it from enough angles.

Here's a simplified (if contrived) example of how it might work. Suppose you were stranded atop a mountain and suddenly your wife, down at the base, calls and asks for the pin number to your debit card. She's got some shopping to do, but just can't seem to find her card! Fortunately, you have already agreed upon a certain N-bit number, V, in advance. So to send your M-bit pin, all you have to do is the following:

Set K = 1.
For M steps:
  If the Kth bit of your pin number is zero:
    Send S = an unbiased, random sequence.
  Otherwise:
    Send S = a sufficiently biased sequence.   
  Set V = V Xor S.
  Increment V.
  Shift K left.

Both parties would obviously be updating V in lock-step. I would think that no one else would be able to make much sense of it though (provided N is large enough of course), just due to the probabilistic nature of the protocol.

Or maybe I'm missing something important here?

 

In case it helps, here's the sample output of "sending" an 8-bit number:

KEY:

1001001001100110000001001111011001110110001101101001111000000100001011101111011000000100001001100100111010100110100001101011011000000100111101100110011000000100100111101111011010101110000001001011011010011110000001000011011011110110011011101010011000000100111011101111011010101110001101100010011000000100010001101010011000000100110011101111011000000100111011101111011001110110001001101010011001001110011001101010111000110110

Message : 235

send : 1 

Shared state (KEY):
0001000010111101110000010010000001000001000001000010100100001000000010000001001100000000101000110000110000000001011010000100000000000000110000001011010000000010100011010010001011111000100110011000011011010010010000001001101010001000001100000010010010000100110001001001100000001000000100100000010000111000000001001100100111000100010100101001001000000000000101000101000000000001010010000011011000111000001001000010010001000100

send : 1

Shared state (KEY):
0110000011000111000010001100000001001110000001100111001001001000010011001001010000000010100001000000000100010111000101100110100000001010000000000000101000010000001101101001010000110100101011011110000110000010000000000001001001000100100111101001101010110101100001101010010001010000110001000011011101101100110100101110000101001000100010101101010010000000001000001010100000100001010011000101010100110001001000001100011110010110

send : 0

Shared state (KEY):
0101111000000000101101100010101001111101110111000111100001110010010010101110011011110010010101010101000001100011101001001001101000010010011111001000110000111101011100111111011001011011010001011100010010111100110001101010011000110100011000000110100100001111010100010010001001010111100001100000001101101001010110110000110101011100000110010101110010011100000100110010001101111111100011010111111100011101000100010010101111111111

send : 1

Shared state (KEY):
1100001100100110100000010000011100011010100001000010101110010000010001001000001000000100100001101001000110010010010000110100110111010100101111010000001000110010010001101110010000010000010010010001100100000001001001000011000100000110010100000001001001101000010101100000001111100101011010001001110101001010100010000100110010000010111010000001000101010010001010100110100011000000000100000111010100110000000101100110101011101000

send : 0

Shared state (KEY):
0101111111110000011001000100001100000010000101110000001100001100100101010110000010001110011001000010010010001110111101011111000001111010110011100011001001101001111000011100101000010100100111100000010110110010001011100110101000010000000110111010101111011000000100000010000011000101111000111101000011110101010101011110010000010101010110010000010111100100110100110111100101011000010100001111010000111010110011110101110101000001

send : 1

Shared state (KEY):
1011101111000000010011110001001000101100100110000011000110010000110000010101100100101101000000010110100110100000000100000010010111101010000000010000001001000000001110100110010011011001011000100011010010000001100000001100000000000001100100001000100001100000001100011101100101100001000000110110010011110010001000010000100011100101110111110001000001010001000101101000100000000100001110100000000100000111001100001000001111100010

send : 1

Shared state (KEY):
0001000000000000100011011000010101001100010000011100001001110011000010001001010010000100001000111000000111000000100010000101011011100100001010000001001000101100011001100010001011000100000010101011100000100000001101001011100100010101000000000111011000101000000000001010000000100110010000011000000101101000000011000001000000101010010110100000000001000001000000000000101111000000110100101001000001000000101000001010101000101011

send : 1

Shared state (KEY):
1000010011000111010010100100001011110000010001010000010000011000000110001111000111100000101001010000010001010010100010000000100000100100111001000000000000110000011111000000010010011010100000100110010000011010000001010000000001001000000010000000001000000001001111000001000001100000000101000010101100000010110001100110010000000001110000010000101101000010010010110010111110000001010001000001001110011010110101000001000000001000

Received : 235

 

Or maybe I'm missing something important here?

I'm not sure I understand your protocol. For the message "101", Alice sends to Bob:

1. an N-bit string randomly chosen from a uniform distribution
2. an N-bit string that's obviously not uniformly distributed
3. an N-bit string randomly chosen from a uniform distribution (different from step 1.)

Is that right? If so, then this is security through obscurity. When adversary Charles intercepts the message, the only thing preventing him from getting the plaintext is a) knowing the mapping random \( \to \) 0, biased \( \to \) 1; and b) the XOR and increment steps. Neither the mapping (guessable in at most two attempts) nor the mixing steps are hard to figure out.

 

I'm not sure I understand your protocol. For the message "101", Alice sends to Bob:

1. an N-bit string randomly chosen from a uniform distribution
2. an N-bit string that's obviously not uniformly distributed
3. an N-bit string randomly chosen from a uniform distribution (different from step 1.)

Is that right? If so, then this is security through obscurity. When adversary Charles intercepts the message, the only thing preventing him from getting the plaintext is a) knowing the mapping random \( \to \) 0, biased \( \to \) 1; and b) the XOR and increment steps. Neither the mapping (guessable in at most two attempts) nor the mixing steps are hard to figure out.

I was wondering about that. But wouldn't it depend on Charles being able to detect the difference in bias? I don't think he could in this situation. Because only some of the data is uniformly distributed (the random parts). The rest is the partial state of V. But ostensibly he would not have a priori access to that knowledge, so how could he even differentiate between the two?

The current implementation uses a 1-out-of-3 bias, but a larger denominator would gradually bring that down towards a uniform distribution. For some reason it just seems like you could tweak that value to ensure secure encoding. But it sounds like what you're saying is that it's easier than one might think to detect such differences?

I'll post a link to a rough mock-up of the protocol HERE in case you want to run it yourself. (Requires Linux.)

 

I was wondering about that. But wouldn't it depend on Charles being able to detect the difference in bias? I don't think he could in this situation. Because only some of the data is uniformly distributed (the random parts). The rest is the partial state of V. But ostensibly he would not have a priori access to that knowledge, so how could he even differentiate between the two?

In your protocol description, the ciphertext -- the message that gets sent in the open -- is a sequence of binary strings, one string for each bit in the plaintext (the hidden message). As you describe it, the mixing with V happens after the string is sent, but this doesn't make sense. So, I'm going to assume you first mix and then send.

I'm also going to assume that V is not a one-time pad (used for one message and thrown away), as then the stuff with the distributions wouldn't be necessary. I'm not clear on the cryptographic role of the distributions. The idea, it seems, is that a string chosen from a biased distribution is subtly different from one chosen from a uniform distribution. Are you thinking that the mixing with V will "blur" that distinction, thus making it safe to send the ciphertext in the open?

Note that, if \( s \) is a binary string drawn from a uniform distribution, then \( s \oplus V \) is also a string drawn from a uniform distribution (provided \( s \) and \( V \) are independent, which they surely are). Since your mixing will not conceal the statistical properties of the strings you send, what's to stop an adversary from analyzing the ciphertext and deriving the 1s and 0s of your plaintext directly, without needing V?

There are other factors, too, but let's make sure we're still on the same page here.

 

In your protocol description, the ciphertext -- the message that gets sent in the open -- is a sequence of binary strings, one string for each bit in the plaintext (the hidden message). As you describe it, the mixing with V happens after the string is sent, but this doesn't make sense. So, I'm going to assume you first mix and then send.


I'm also going to assume that V is not a one-time pad (used for one message and thrown away), as then the stuff with the distributions wouldn't be necessary. I'm not clear on the cryptographic role of the distributions. The idea, it seems, is that a string chosen from a biased distribution is subtly different from one chosen from a uniform distribution. Are you thinking that the mixing with V will "blur" that distinction, thus making it safe to send the ciphertext in the open?


Note that, if \( s \) is a binary string drawn from a uniform distribution, then \( s \oplus V \) is also a string drawn from a uniform distribution (provided \( s \) and \( V \) are independent, which they surely are). Since your mixing will not conceal the statistical properties of the strings you send, what's to stop an adversary from analyzing the ciphertext and deriving the 1s and 0s of your plaintext directly, without needing V?


There are other factors, too, but let's make sure we're still on the same page here.

Sorry, I should have been clearer. This is the loop simulating the transmission of the data:

while(count--)
{
  block_copy(int, input, biased);
  randomize_biased(&biased);
  randomize(&random);
  int send = bitbox & 1;
  bitbox >>= 1;
  if(send)
   transform(input, biased, &input);
  else
   transform(input, random, &input);
  showl(send);
  puts("Shared state:");
  binp(input);
  if(send)
   received |= msb;
  msb <<= 1;
}

After each bit is "sent", the input (or key) is updated with the data of chosen distribution. So that would be more like a synchronized key transform than a one time pad.

As to whether or not the selection process is undetectable, I'm not sure if I'm ready to rule it out. At this point I really just need to try to "crack" it with some analysis. Shouldn't be too hard, right? (!!!)

 

I still don't get it. Let's do a simple example: you want to send me a secret 3-bit message: 101. You and I both have the same key (V), which I'll say is "001". Can you describe what happens next, and especially, what gets sent in the clear?

 

I still don't get it. Let's do a simple example: you want to send me a secret 3-bit message: 101. You and I both have the same key (V), which I'll say is "001". Can you describe what happens next, and especially, what gets sent in the clear?

Sure.

~ Copy the current V to S1 [001]
~ For each bit in S1, randomly flip (invert) a bit 1/3 of the time [(1)01]
~ Create a random sequence S2. [110]
~ Bit #1 is 1 so send S1 [101]
~ V = V Xor S1 [100]
~ V = V + 1 [101]

~ Copy the current V to S1. [101]
~ For each bit in S1, randomly flip (invert) a bit 1/3 of the time [1(1)1]
~ Create a random sequence S2 [010]
~ Bit #2 is 0 so send S2 [010]
~ V = V Xor S2 [111]
~ V = V + 1 [000] (Truncated to three bits)

~ Copy the current V to S1. [000]
~ For each bit in S1, randomly flip (invert) a bit 1/3 of the time. [0(1)0]
~ Create a random sequence S2. [011]
~ Bit #3 is 1 so send S1 [010]
~ V = V Xor S1 [010]
~ V = V + 1 [011]

Initial state of V: 001
Final state of V: 011
Message sent: 101

 

Over the passed few days I've been thinking about the possibility of sending bits over "probabilistic" connections.

I've already put together a crude working prototype, and although it does "work", I'm wondering just how secure it is. I can't seem to think of any way that the data could be compromised in transit, but like I said, I just don't know if I've looked at it from enough angles.

Here's a simplified (if contrived) example of how it might work. Suppose you were stranded atop a mountain and suddenly your wife, down at the base, calls and asks for the pin number to your debit card. She's got some shopping to do, but just can't seem to find her card! Fortunately, you have already agreed upon a certain N-bit number, V, in advance. So to send your M-bit pin, all you have to do is the following:

Set K = 1.
For M steps:
  If the Kth bit of your pin number is zero:
    Send S = an unbiased, random sequence.
  Otherwise:
    Send S = a sufficiently biased sequence.  
  Set V = V Xor S.
  Increment V.
  Shift K left.

Both parties would obviously be updating V in lock-step. I would think that no one else would be able to make much sense of it though (provided N is large enough of course), just due to the probabilistic nature of the protocol.

Or maybe I'm missing something important here?

How does anything that either side does depend on the pre-shared secret key?

K deterministically starts out at 1.
The loop is deterministically executed M times where M is the number of bits in the message.
On each pass we then examine a particular bit in the message and if it is 0 we send an "unbiased, random" sequence", but if it is 1 we send a "sufficiently biased" sequence. What does you wife do when she received it? Presumable it must be "sufficiently biased enough" so that she can detect that it is and thus decide whether the message bit is a 0 or a 1. But what prevents the eavesdropper from doing exactly the same thing?
You then modify V by xor'ing it with the sequence you sent and then increment V (which serves what purpose). So while you are changing V, you are never actually using it!
You then shift K to the left, which has the effect of doubling K.

Since you double K on every pass, you examine bits 1, 2, 4, 8, 16, .... You thus leave most bits unexamined and very quickly are trying to examine bits that aren't in the message.

If you have a pre-shared secret, why not use one of the standard symmetric encryption algorithms. Or why not use something like Diffie-Hellman to exchange the information without even relying on a preshared secret at all.


Where does your algorithm does use your agreed upon N-bit number

 

From your later posts I think I see what you are intending to do and it has some pretty gaping blow holes in it.

If I XOR consecutive transmissions with each other, I get a good sense for the fraction of bits that were changed and hence whether they were changed randomly or in a very nonrandom way.

Things are even worse for the sequences transmitted with runs of 1 bits in the message.

 

If I XOR consecutive transmissions with each other, I get a good sense for the fraction of bits that were changed and hence whether they were changed randomly or in a very nonrandom way.

Things are even worse for the sequences transmitted with runs of 1 bits in the message.

And I am certainly open to that idea. But how exactly do you even go about extracting anything useful from the exchange in the first place?

Initial shared state:
10001100010011001100110000101100001011001100110000101100110011000010110011001100010011000100110011001100001011000100110011001100001011000001110000001100010011001100110000011100001011000000110000011100010011001100110000001100001011001001110000011100000011001001110001001100110011000001110000101100000011000100110011001100000111000010110000001100010011000001110011001100001011000000110001001100100111000001110011001100001011000100110011001100
message : 71
send : 1
Shared state:
00011010111010011000000000101100000100010000000100111100001000000000100011001100001011100110000000000010000101000000000000001001000101010000000010000101101111000100010011011000101001001100100111100000100010110001001010101001000100111010000001010100000001000111001001001011001000001001110110010010100000101000000010110000010010001010011001010100100000100000000110000010000100111010100100000101001100010001000010000001001000100011110010000110
Hints:
10010110101001010100110000000000001111011100110100010000111011000010010000000000011000100010110011001110001110000100110011000101001110010001110010001001111100001000100011000100100010001100010111111100110001111101111010100101001111110011110001001000000010001110111000000111111011001000000110111110100011101100110001111100010101001000101001011000110011100001110101001110001111111010010101001001101011010000110001001101000011100111000001001010
send : 1
Shared state:
10000010100010010100100001011000101001000000000000011000001001010010101001100000000110100101110001010000001100000101010001100101000000001011111110000010011000011101000000110101101111001001101001011000010101001011100001000000010011010001110111101000010000100000000000111101000111000100010100001100001101010000100000010100000011000100111110000000111000000010101110000000101100011000011011011011000100000011001001100001010000010100001000101010
Hints:
00010100001011000000010001011000100110011100110100001000110010010000111001100000011110000111000010011110000010000001100010100000001110011010001100001011100100010101100011110001001101000101111110100100100100110110011011100101011100100010000110100000010010101110111000111010111100001100010010110010101110111100010001101000010110001100010111011000001011100011011011001110100011100010001110010010101111010011111000101100010011110011001001100000
send : 1
Shared state:
00010111000000011010000011000110101001001101001000100111000100010010001000000110000000010101000000100001000100000001000000101101000110010101000000000100010001000001000010111100111000010110110011000000000101000000010001011000101111000000011100100101110100000000000010001011000000000011000101010011000010000010110000110001000100000000100100011000010000000001000000001010100000100010010000000001000011010011111010000001110001010000100110010101
Hints:
00000011001011011010010010011110001111010001111100101111110110000010110001100110011110010010000010111111000110000000100010001101001000001111001100001111110101010100100001001101110101010011001101100100100001110110001010111101110011100010011010000101100110101110111010110001111100001111010111100001101100111110100001011001010010001100110011000000011011100010011011000100000011000000011110010011101100000000000010101101100010100011101111110101
send : 0
Shared state:
10001111011000010110100010110010000100011101001100000011000101000000000010101010001101010110110001110011001101000100010001000001000011001110111100000011100110011000010001010001111110010011111101111000110010111010111010110001111000101011101010011001100101100111001011111101001111001110100111001101101111111010010010010101010101001110000011001100001000100011101000001000001000000000101111011111001011000001110001100001101001100111011100111001
Hints:
10001100010011001100110000101100001011001100110000101100110011000010110011001100010011000100110011001100001011000100110011001100001011000001110000001100010011001100110000011100001011000000110000011100010011001100110000001100001011001001110000011100000011001001110001001100110011000001110000101100000011000100110011001100000111000010110000001100010011000001110011001100001011000000110001001100100111000001110011001100001011000100110011001100
send : 0
Shared state:
10001111101010000110100010100000100110111001001100010001001110101010111000001011000010010110011001010001101111001000101001010001000011011011111100100001000001101010110000100110110011010110111101011010000000110010111110100101111111000100101010110001100001111110100011011110000101101010010101001101100001101110010000111111010111001111000100000100000010110101001000101110001000001110110001101111101011100011110001101100100010000111011100110101
Hints:
00000011111001001010010010001100101101110101111100111101111101101000001011000111010001010010101010011101100100001100011010011101001000011010001100101101010010100110000000111010111000010110001101000110010011111110001110101001110100001101011010101101100010110111010010010010110110101011100101100001100010101010100011110011010000001101110100001000010001110100111011100010000011001110000000100011001100100010000010100000101001000011101111111001
send : 0
Shared state:
10001100101000000110111011111100100110100001010110010101101110101000111011010110111010000100110001010101101010001101101011000111100010011010101100101001100001100011011100100111110000010111001001111011000010000000010000000111001010010100101110110001110000111011001101110010000111011110000111101011111001101100111001101111011010000110000000000100001110110100001000100110001101001110110001011011110010001111010001101001100110000100001111110100
Hints:
10001111010001001100101001110000001011010100101010101000010011000000110000010001101011010110011011001000001110000001110001011010101010000000100000000100110011000101011100011101001000000001000100111101010001111110011110101110111110011001110100011100010010001100011111100000110001110101100010001010011011000110011010011100001010001011110100001100011111000000110011000100001110000000110001111000111110101101010011001001001111000111100000001101
send : 1
Shared state:
10100000100100000001001000000100010010001101100101000110010001011001110010110001111000100011010001010000010000100110011010001011000100111010011100100101100110011011000010001101010101010010010010101101000001110100100000101100100001000000000000110010001100100000001110000010100011011100101101110010101100000000100000001000001001011001101001001010011111000010010100010100000110000000001000101000010000010000100001000100001010001001001011000101
Hints:
00101111110101001101100001110100011001011001001111101110000010011001000010100000010011110101001010011000011110100111101011010001101110111010111100100001010101011110011110010000011101010011010110010000010000001010111110000010011111011001110100101110011110101100010001100010010010101001001111111000110111000110111010010100000011010010011101000110000000000010100111010000001000000000111001010000101110111101110010001101000101001110101011001000
send : 0
Shared state:
10101000001000010111101010111001101100011010000011010110011011110001001001100110000110100110000110000101011000111101110001001000000111110000010011010001101010111000001110100100011101010011111001100010000111011101110000111011110000010001111010101101011101011011010101100001100110010001101010011001110000001100110001110101101010111001101110011100001000110100111111011010011011001101100011010110101001011111110110111000001100001001100100010010
Hints:
10000111111101011010001011001101110101000011001100111000011001101000001011000110010101010011001100011101000110011010011010011001101001001010101111110000111111100110010000110100000000000000101111110010010111010111001110111001101111001000001110000011000011110111000100000011110100111000100101100001000111001010001011100001101001101011110011011010001000110110011000001010010011001101011010000110000111100010000100110101001001000111001111011010
Final shared state:
10101000001000010111101010111001101100011010000011010110011011110001001001100110000110100110000110000101011000111101110001001000000111110000010011010001101010111000001110100100011101010011111001100010000111011101110000111011110000010001111010101101011101011011010101100001100110010001101010011001110000001100110001110101101010111001101110011100001000110100111111011010011011001101100011010110101001011111110110111000001100001001100100010010
received : 71

I just can't see any correlation there.

 

Whoops, I was XOR'ing the wrong things together! Here it is, a running XOR of the "visible" transmission:

Initial shared state:
10001100010011001100110000101100001011001100110000101100110011000010110011001100010011000100110011001100001011000100110011001100001011000001110000001100010011001100110000011100001011000000110000011100010011001100110000001100001011001001110000011100000011001001110001001100110011000001110000101100000011000100110011001100000111000010110000001100010011000001110011001100001011000000110001001100100111000001110011001100001011000100110011001100
message : 242
send : 0
Shared state:
10110100110101000001001011000110100101011101110110010100001110011101010001001101111100111111100001011110010011001100110010001101010000000111000010110001001111010100001000100100011100011111110010100001110101101001010100001011101000001101011000001011101000110100100010101010111011010001001010011000101100110110111011011100010110001110000111001001111110010111101100001011010111101001111111101000100101011001111111111000100110111101100111110000
Hints:
00110100110101000001001011000110100101011101110110010100001110011101010001001101111100111111100001011110010011001100110010001101010000000111000010110001001111010100001000100100011100011111110010100001110101101001010100001011101000001101011000001011101000110100100010101010111011010001001010011000101100110110111011011100010110001110000111001001111110010111101100001011010111101001111111101000100101011001111111111000100110111101100111110000
send : 1
Shared state:
00100000111001101001000011010100001101100011110001010000001011000010000001000110000000011100001100000000100000001010010000000010110000000000000010000010011100011010100100100000010000000001010000010100000000000010010010100011101100100010110010100010000100000010000110100011100100111010111110000101011100000000001000000110001001001001001000101010101000011010001000000000010000010100000000011010010000011110000100100011000101000010000011001001
Hints:
10101000000101011010111101000001101110111110100100100000011101100101010000101000010100101011011101001101110111010010110110001011100000000110001001010001110111011010100101101101101010110111110001110000111010100010000000001001000111101010001011101001001000110101000100101011111110100010101110111100011001100101100011101111001100110101101111010011000110110111000000110011010011110111111111110001111100010111011011010101001001010111110001110001
send : 0
Shared state:
01011100110000011011110110000111001011100011010010110100010011111000000001100101101000010100111100010011100100011110000100000110110000000001001011100000111000001110101101001001110110101000000011010001001111001011010100000010101111100111010011100010100000000001100110000001000101110011100100100100110101010011011000110011011010111011101000011010111000100000101100111000000100011110000000011001011001001110100100101101101111101010010110000001
Hints:
10101000000101011010111101000001101110111110100100100000011101100101010000101000010100101011011101001101110111010010110110001011100000000110001001010001110111011010100101101101101010110111110001110000111010100010000000001001000111101010001011101001001000110101000100101011111110100010101110111100011001100101100011101111001100110101101111010011000110110111000000110011010011110111111111110001111100010111011011010101001001010111110001110001
send : 0
Shared state:
11101011111000011101110110010111101011110011010000011101001010101010010001000111100100000000010100010001100100011001001100111110110000001011001011100101100100110110100111111011010110110000110001001100101011110010101100000001001101000001010001101000000001100111101010100101001101110011100110000100111010010010101001111010011000100110001110011001001000110000100110010001001101010010110110011000011001101100110110111100011100100001011000000001
Hints:
10101000000101011010111101000001101110111110100100100000011101100101010000101000010100101011011101001101110111010010110110001011100000000110001001010001110111011010100101101101101010110111110001110000111010100010000000001001000111101010001011101001001000110101000100101011111110100010101110111100011001100101100011101111001100110101101111010011000110110111000000110011010011110111111111110001111100010111011011010101001001010111110001110001
send : 1
Shared state:
11000011000001110100011110000000011010000000000000010010100110110100100001010110000011010010000001000111010110011000001000010000001000010100000100100000000111000100101000000010101000001000110101000010000110000101111000111000010001010011011100110010010011111010010011001101110101001101101010100101011100001010010000010010000101100010101000000000000000110000010000111011000100001000000000010001010111110000000011000000000010000010010100000000
Hints:
10001000011000110110010101010110011101001011110000011100110001110000010111110011100101110111011000010011000111110001110011110100101001110100100111010100000100111100011111010101010100111110111010000010010001110000010101000110001011111100111000110110000010111111011011011011011000111000000010010100011101011101011110001111010000100001101011111000101110110101011110001001110110111010101101110001101011100111101011010011011110001100110011001100
send : 1
Shared state:
11000110101001100000011100010000001010010000010001100010100100001111001000010101000110010011010101100000000011001100100010000000100001100100000000000000000000000000001101001000101000100001110000001110000011000011101001100010001000000110011100000000000000011100000001000111000000000100000100000000000000001000001000100000010000000001010001011001000101000000010000000000011110010000000001011000011001110010100000110001100000101100100001000101
Hints:
11101110101100111010100001010001100100101110110101000010111001101010011000111101010010111000001000101101110100011110010100001011000001100010001001010001110111011010101000100101000010010110000001111110111001100001101001101011001111101100010111101001001000101001000101101100111110100110101010111100011001101101101011001111011100110100111110001010000011110111010000110011001101100111111110101001100101100101111011100100101001111011010000110100
send : 1
Shared state:
10010011110011000100001001100110011011110000000110000000011001000111100100100100011000011010010100101000010000110101000100001000000000100010000000011100001011001000101010100000010001000010101010010000000100000100001011011100100000000000010010011101011010011000010110001100010110001000010100110001001000100000000100001001000001100000010001001000010001100000000100111001100010011100101001001001000011000010010100100000001100000100110100001101
Hints:
10011011101011110010011100110000000110111011110110011100101000110111110011010111111101101101001100111011010111000100110111111100101001010110100111001000001111110100110101110101000101111100010000010010010101110100011110011010101011111100101010101011011000100111001101010111001110110000010110100101010101111101011010000110010001000001111010110000111111010101011010110000010100100110000100111000101000100101111111110011010010001000000111000001
send : 1
Shared state:
10000100000001000001100010000010000101010100000000101100001001010100100110000010001000100011000001000100000101001100001110000010100000010110001011100000101000110010000010001110000100100000000010110100101000000010001000000000001110000111110001010000000010100010000000000110000000100110000010000000100100100010010100000010001110010001100000001100000101000101000000100110001001010001000000000100010010001001001001001010001000101000000000101101
Hints:
11101010101101111011000011010011100001111010110101101110110000111110111110111111011010011011001001101001110001010010011010001001100001110100000010110001011111101000101010101011000110110110000011001010010001100011100001101011000001101011100110111001001010001011000101101010111110000000101000111100111101001111111111001101010010100101011110000110000110110010010000010101000100110110111110101101110111101100110010101110100001010011010000011001
received : 242

Wait, either I did something else wrong there...or you may just be right after all. Please hold...

 

Yep, confirmed. Well, I'm still wondering if some other encoding scheme could be used. I know, I know. Probably not!

 

Yep, confirmed. Well, I'm still wondering if some other encoding scheme could be used. I know, I know. Probably not!

You hit the nail on the head in the first post:

I can't seem to think of any way that the data could be compromised in transit, but like I said, I just don't know if I've looked at it from enough angles.

This is where all of the people, Zoom being the most notable this week, that roll their own crypto go wrong. They get to the point you did and THEY can't think of a way to compromise the data, and so they stop there and call it good. At least you took the next step and published your work for OTHERS to take a look. This is why security-through-obscurity owns the well-deserved horrendous reputation that it does.

Just consider that virtually every security protocol that has ever been invented has contained exploitable weaknesses that have been identified, even ones that went through years of extensive examination and testing and attacking by the best minds in this field from all over the world. The NSA even broke enough of the Soviet one-time-pad ciphertext to expose multiple spy rings operating in the U.S. -- and the unbreakability of the one-time-pad cipher is mathematically provable! But put a relatively minor, low risk variation in the protocol used into the mix, and you end up with spies in the electric chair.

Put in that perspective, the thought that you or I could possibly come up with an encryption scheme that could stand up to even a mild effort by these same folks comes close to the height of temerity. Which is not to say that the attempt is without merit, particularly if the goal is primarily to exercise and develop our own abilities in this area.

When I was doing the work that ended up being my dissertation topic, my colleague and I would sit around the lunch table presenting our newest great ideas to each other and then promptly shooting them down -- he usually riddled mine within minutes, I often took an hour or day to deflate his bubble. This went on literally for about three years. At the end, we had something (mostly his work) that we felt really good about and published it -- and not long after he found an exploitable weakness in it. The revised version has, thus far, stood up -- but there's been very little analysis and testing by others in the field, so we are in no position to declare it secure.

 

You hit the nail on the head in the first post:




This is where all of the people, Zoom being the most notable this week, that roll their own crypto go wrong. They get to the point you did and THEY can't think of a way to compromise the data, and so they stop there and call it good. At least you took the next step and published your work for OTHERS to take a look. This is why security-through-obscurity owns the well-deserved horrendous reputation that it does.


Just consider that virtually every security protocol that has ever been invented has contained exploitable weaknesses that have been identified, even ones that went through years of extensive examination and testing and attacking by the best minds in this field from all over the world. The NSA even broke enough of the Soviet one-time-pad ciphertext to expose multiple spy rings operating in the U.S. -- and the unbreakability of the one-time-pad cipher is mathematically provable! But put a relatively minor, low risk variation in the protocol used into the mix, and you end up with spies in the electric chair.


Put in that perspective, the thought that you or I could possibly come up with an encryption scheme that could stand up to even a mild effort by these same folks comes close to the height of temerity. Which is not to say that the attempt is without merit, particularly if the goal is primarily to exercise and develop our own abilities in this area.


When I was doing the work that ended up being my dissertation topic, my colleague and I would sit around the lunch table presenting our newest great ideas to each other and then promptly shooting them down -- he usually riddled mine within minutes, I often took an hour or day to deflate his bubble. This went on literally for about three years. At the end, we had something (mostly his work) that we felt really good about and published it -- and not long after he found an exploitable weakness in it. The revised version has, thus far, stood up -- but there's been very little analysis and testing by others in the field, so we are in no position to declare it secure.

I agree. It is foolish to rely on "security through obscurity", and yet so many do. As for me, I'm just the brain-storming type I guess. Sometimes it yields a gem, some times it doesn't. It's a messy process. ;p

This is a difficult problem though. Lots of things to consider...

 

I agree. It is foolish to rely on "security through obscurity", and yet so many do. As for me, I'm just the brain-storming type I guess. Sometimes it yields a gem, some times it doesn't. It's a messy process. ;p

This is a difficult problem though. Lots of things to consider...

Lots of extremely subtle things to consider -- and lots of very brilliant people have been considering them for about a century now and still they find new things on a fairly regular basis.

Some of the cadets did a project this semester where they essentially recreated one of the classic Tempest breaks and did it by simply placing an antenna near (within about six inches) the shielded HDMI cable going from a laptop to the monitor and were able to reproduce the image on the screen with pretty remarkable resolution. Their hardware cost was in the neighborhood of $50 and was completely off the shelf. A bit of programming on the received signal and they had it. Their next step is to try a bit more expensive set up and perhaps a directional antenna and see if they can extend the distance to the next room.

One of the breaks I always thought was clever was to take a key card and extract the key by having it process an input while exposing it to a level of radiation that slowly erases the bits in the key. Every time the hash changed, they knew another bit had changed and the rate was slow enough so that they were effectively guaranteed that only a single bit would change at a time. Eventually all the bits were erased and now they had a known key and hash. Then all they had to do was walk back and brute force each of the bits in the key until they found the last key that had but a single bit set that produced the observed hash. Then they did it for the second to last bit to get erased using the hash before that and so on. IIRC they got the process down so that they could extract the key in less than handful of minutes. At that point they could program new key cards, including one that looked like the original, and replace it so that the legitimate owner wouldn't know it had been compromised.

The attacks on the various WiFi protocols are an interesting study in and of themselves. And now WPA2 is broken (KRACK -- though other weakness have been found previously), as well, with no replacement on the horizon since the WPA3 (announced just last year) has been shown to be vulnerable to a new attack (Dragonblood). Fortunately, ways to protect against the WPA2 vulnerability seem pretty effective -- but how many people are actually applying them (I know I haven't even checked to see if I am or not -- or whether my hardware even can apply them).

 

One of the breaks I always thought was clever was to take a key card and extract the key by having it process an input while exposing it to a level of radiation that slowly erases the bits in the key. Every time the hash changed, they knew another bit had changed and the rate was slow enough so that they were effectively guaranteed that only a single bit would change at a time. Eventually all the bits were erased and now they had a known key and hash. Then all they had to do was walk back and brute force each of the bits in the key until they found the last key that had but a single bit set that produced the observed hash. Then they did it for the second to last bit to get erased using the hash before that and so on. IIRC they got the process down so that they could extract the key in less than handful of minutes. At that point they could program new key cards, including one that looked like the original, and replace it so that the legitimate owner wouldn't know it had been compromised.

The name's WBahn. James WBahn. =D

The attacks on the various WiFi protocols are an interesting study in and of themselves. And now WPA2 is broken (KRACK -- though other weakness have been found previously), as well, with no replacement on the horizon since the WPA3 (announced just last year) has been shown to be vulnerable to a new attack (Dragonblood). Fortunately, ways to protect against the WPA2 vulnerability seem pretty effective -- but how many people are actually applying them (I know I haven't even checked to see if I am or not -- or whether my hardware even can apply them).

And the problems only seems to be getting worse too. It's kind of overwhelming, isn't it?

 

And the problems only seems to be getting worse too. It's kind of overwhelming, isn't it?

From certain perspectives, they are and it is.

We increasingly rely on increasingly complicated and sophisticated systems that we increasingly interact with at increasingly higher levels of abstraction that it is becoming increasingly impossible for anyone to understand the systems they are using well enough to actually assert control over them. And that's everyone. Sure, Person A might know enough about System X to assert firm control, but the skills and knowledge needed to do so mean that they have had to forego gaining the skills and knowledge needed to control Systems Y and Z.

Thirty years ago it wasn't that hard to understand enough about the computer sitting on your desk to exert full control over it. Now, certainly most people didn't have that understanding, but there were a lot of people that did. Today, I would not be surprised to learn that there is not a single person on the planet that can make that claim. They might know exactly how this works or that works and how to control it in fine detail, but they don't know how the entire computer works in that kind of depth.

Just think about today's cars compared to those from thirty years ago. I could draw out nearly the entire electrical system of my car (okay, it was a 1971 model, so 50 years ago) and, even as an 16 year old, describe in pretty accurate detail how everything worked on that car. I even had a fair understanding of how the automatic transmission worked and things such as how the engine vacuum interacted with it. There were certainly some things that were a bit handwavy and I couldn't have describe how very much of it was designed, and there were some errors in my understanding, to be sure. But it was simple enough that, as a 16 year old, I could troubleshoot and repair virtually everything in the car. Today I couldn't even begin to tell you how the ignition system works on any vehicle I own -- and the newest of them is 15 years old. I'm not even sure how accurate my handwavy description would be.

EDIT: Fix typos.

 

From certain perspectives, they are and it it.

We increasingly rely on increasingly complicated and sophisticated systems that we increasingly interact with at increasingly higher levels of abstraction that it is becoming increasingly impossible for anyone to understand the systems they are using well enough to actually assert control over them. And that's everyone. Sure, Person A might know enough about System X to assert firm control, but the skills and knowledge needed to do so mean that they have had to forego gaining the skills and knowledge needed to control Systems Y and Z.

Thirty years ago it wasn't that hard to understand enough about the computer sitting on your desk to exert full control over it. Now, certainly most people didn't have that understanding, but there were a lot of people that did. Today, I would not be surprised to learn that there is not a single person on the planet that can make that claim. They might know exactly how this works or that works and how to control it in fine detail, but they don't know how the entire computer works in that kind of depth.

Just think about today's cars compared to those from thirty years ago. I could draw out nearly the entire electrical system of my car (okay, it was a 1971 model, so 50 years ago) and, even as an 16 year old, describe in pretty accurate detail how everything worked on that car. I even had a fair understanding of how the automatic transmission worked and things such as how the engine vacuum interacted with it. There were certainly some things that were a bit handwavy and I couldn't have describe how very much of it was designed, and there were some errors in my understanding, to be sure. But it was simple enough that, as a 16 year old, I could troubleshoot and repair virtually everything in the car. Today I couldn't even begin to tell you how the ignition system works on any vehicle I own -- and the newest of them is 15 years old. I'm not even sure how accurate my handwavy description would be.

Several tens of examples like this William; no surprise then.

 

Several tens of examples like this William; no surprise then.

That's actually a great example!

Can you even buy a new toaster that is the old fashion kind that is little more than a bunch of nichrome wire and a bimetalic switch to act as a temperature switch to release the catch mechanism? We don't use a toaster much, but the one I have is the one that my grandmother had and it is probably from the 1950s or 60s. Still works just fine.