-5

Can I locate/access Francis Litterio's article "Why are one-time pads perfectly secure?"

closed as off-topic by multithr3at3d, forest, Steffen Ullrich, schroeder May 21 '18 at 8:18

This question appears to be off-topic. The users who voted to close gave this specific reason:

  • "This question does not appear to be about Information security within the scope defined in the help center." – Steffen Ullrich, schroeder
If this question can be reworded to fit the rules in the help center, please edit the question.

1

I don't really get your question but here's what I think you requested:

https://securityaware.wordpress.com/2008/07/15/art/ - Article by Francis Litterio's :

First, I describe how an xor-based one-time pad (OTP) cipher works. Then, I show why xor-based OTPs are perfectly secure against ciphertext-only cryptanalysis.

What is a One-Time Pad?

A one-time pad is a very simple yet completely unbreakable symmetric cipher. “Symmetric” means it uses the same key for encryption as for decryption. As with all symmetric ciphers, the sender must transmit the key to the recipient via some secure and tamperproof channel, otherwise the recipient won’t be able to decrypt the ciphertext. The key for a one-time pad cipher is a string of random bits, usually generated by a cryptographically strong pseudo-random number generator (CSPRNG). For more information, see David Deley’s Computer Generated Random Numbers. It is better to generate the key using the natural randomness of quantum mechanical events (such as those detected by a Geiger counter), since quantum events are believed by many to be the only source of truly random information in the universe. One-time pads that use CSPRNGs are open to attacks which attempt to compute part or all of the key. With a one-time pad, there are as many bits in the key as in the plaintext. This is the primary drawback of a one-time pad, but it is also the source of its perfect security (see below). It is essential that no portion of the key ever be reused for another encryption (hence the name “one-time pad”), otherwise cryptanalysis can break the cipher. The cipher itself is exceedlingly simple. To encrypt plaintext, P, with a key, K, producing ciphertext, C, simply compute the bitwise exclusive-or of the key and the plaintext:

C = K^P

To decrypt ciphertext, C, the recipient computes

P = K^C
It’s that simple, and it’s perfectly secure, as long as the key is random and is not compromised.

Why Are One-Time Pads Perfectly Secure?

If the key is truly random, an xor-based one-time pad is perfectly secure against ciphertext-only cryptanalysis. This means an attacker can’t compute the plaintext from the ciphertext without knowlege of the key, even via a brute force search of the space of all keys! Trying all possible keys doesn’t help you at all, because all possible plaintexts are equally likely decryptions of the ciphertext. This result is true regardless of how few bits the key has or how much you know about the structure of the plaintext. To see this, suppose you intercept a very small, 8-bit, ciphertext. You know it is either the ASCII character ‘S’ or the ASCII character ‘A’ encrypted with a one-time pad. You also know that if it’s ‘S’, the enemy will attack by sea, and if it’s ‘A’, the enemy will attack by air. That’s a lot to know. All you are missing is the key, a silly little 8-bit one-time pad. You assign your crack staff of cryptanalysts to try all 256 8-bit one-time pads. This is a brute force search of the keyspace. The results of the brute force search of the keyspace is that your staff finds one 8-bit key that decrypts the ciphertext to ‘S’ and one that decrypts it to ‘A’. And you still don’t know which one is the actual plaintext. This argument is easilly generalized to keys (and plaintexts) of arbitrary length.

by Francis Litterio

StackExchange Answer

0

A one-time pad basically uses an encryption key that is as long as the message it is encrypting. XOR with the key to encrypt, XOR again to decrypt. Providing you have a secure means of pre-sharing that key, and you only use it once, and there is no way of predicting the key (ie it's completely random), there is no way to crack it. You can't exploit any predictability in parts of the message to derive the key and thus unlock the rest of the message: even if you know 50% of the message, the other 50% is opaque.

There is thus no magic to it, and it is dead simple, but its claims of security come with very big qualifiers: it all hinges on being able to securely share that key beforehand. If you have a very long message to transmit, you also need to have transmitted that very long key separately, in a secure way. And if you have pre-generated and pre-shared excess "key" in order to cut down on this, then it still needs to be stored securely in the meantime.

Not the answer you're looking for? Browse other questions tagged or ask your own question.