Public .exe Cryptosystem

This Is Weak Crypto

The Public Key-Like Cryptosystem presented here is based on ideas published by someone on sci.crypt during March of 2011. (Public Key Exchange by Exchanging Hash Functions, March 15, 2011). It uses a symmetric key algorithm like DES, but in an unusual way. DES has two input ports and one output port. The input ports are the key and the plaintext. The output port is ciphertext. This new protocol publishes using only one of those input ports being available to users.

The private publisher of the .exe file retains full control of the two input ports so she can use a private key. The public users of the public EXE cryptosystem software only see one input port where plaintext is applied.

The new Public EXE Cryptosystem scheme keeps the key secret by obscuring it in a custom program: an .exe file. The key is in the .exe file after being folded into logic as hard-coded ones and zeros that are hard to find. A CAD system takes the key and hides it in a .exe file, which is published. That is like a public key being published. The .exe file will let any public person enter a plaintext and get a ciphertext. But since the key is so hidden in the .exe file logic that the public person cannot find it, she cannot decrypt hur own ciphertext. That is like a public key cryptosystem where she can encrypt a file but cannot decrypt it because she does not have the secret key.

The Public EXE Cryptosystem publishes an algorithm similar to Serpent or DES, but with only one input port.

Start with a block cypher such as DES. It can be represented as a 
"circuit diagram" graph of AND/OR/NOT/etc gates, with the plaintext 
and key bits as inputs, and the cyphertext bits as output. Hardware 
engineers do this sort of thing all the time. 
Fix the key bits to known values, and apply constant-folding and other 
optimisations to the graph. The key schedule is now determined, so it 
gets optimised out; the cypher will be optimised too, and we'll end up 
with a "specialised" DES function that encrypts a plaintext block with 
the key we provided. 
How hard would it be to determine the DES key from the graph? 
I doubt it would be very hard at all, since DES wasn't designed with 
this use-case in mind, but if the cypher had the property that it was 
hard for an attacker to determine the original key after optimisation, 
you could publish the resulting graph as your public key and keep the 
original key private. 

I publish a program executable that strangers run to 
encrypt a message. But they cannot decrypt it without the private key. 
I receive the cipher text and use the private key to decrypt the 
message. To break the system, some smart attacker needs to evaluate 
the executable to derive the key.  When the attacker succeeds, he 
publishes new software to break any future transaction. The attack is 
easier than a brute force search of all keys. If the system is 
publicly known and only the key is secret, the attacker has an easy 
job. But if the system is variable, not always DES, the attack seems 
impractical. Bravo! Security by obscurity now has a reason to thrive! 

Like a Public Key Cryptosystem, the new Public EXE Cryptosystem works as follows for exchanging keys to ordinary symmetric ciphers:

The Steuert Corporation sells a CAD program that produces a variable cipher, similar to Rijndael and DES. Alice and Bob and a million other folks each buy a copy for $20. They use it for key deliveries for AES.

Alice creates a program .exe file and keeps the private key. She publishes the .exe file as a public key.
Bob creates a program .exe file and keeps the private key. He publishes the .exe file as a public key.
Alice chooses an AES key and encrypts it with Bob's Public EXE. She sends the ciphertext to Bob.
Bob chooses an AES key and encrypts it with Alice's Public EXE. He sends the ciphertext to Alice.
Alice uses her private key to decrypt Bob's AES key.
Bob uses his private key to decrypt Alice's AES key.
The key exchange is now complete, so they are done using The Steuert Protocol. They can move on to sending AES encrypted messages to each other using the ordinary AES algorithm using the keys they exchanged semi-securely. It is less secure than a Public Key Cryptosystem, but it is secure enough for rock and roll. A 10kilobyte EXE program has lower security than a 5000kilobyte EXE program, which is selectable by the CAD program.