Log Message:
Import dhbitty-20120812 into the Packages Collection.

	dhbitty is a small public key encryption program written in C.  It
	uses elliptic curve Diffie-Hellman in the form of Curve25519 to
	establish a shared secret between two users, and uses that secret to
	symmetrically encrypt and authenticate messages.

	There are no private key files; only passphrases.  Never lose that
	pesky thing again.

	Both the sender and the receiver can decrypt a message.  In fact,
	there is no distinction between sender and receiver.  Both passphrases
	must be strong.

	There is no signing.  A similarly useful form of authentication occurs
	using only DH.  dhbitty attempts to be as simple as possible.  It is
	not optimized, but achieves a comfortable speed for most uses.  It
	does not use floating point numbers, or integers longer than 32 bits.
	It does not contain more algorithms than are needed.

Example                                                                          \ 
                                                      
                                                                                 \ 
                                                      
   This is how Alice generates her public key with dhbitty:
$ dhbitty generate alice_public_key.txt
username:passphrase (this is visible!): alice:Keyfiles be damned!
Done.

   Bob will do the same thing:
$ dhbitty generate bob_public_key.txt
username:passphrase (this is visible!): bob:Bob's Spectacular Passphrase
Done.
                                                                                 \ 
                                                      
   Alice will publish her alice_public_key.txt, and Bob will publish his \ 
bob_public_key.txt. They can now access each other's
   public keys. (But they should be careful that Eve cannot surreptitiously \ 
replace either public key with her own!)

   Alice wants to send files to Bob. She packages them into a .tar archive (or \ 
any other type of archive with timestamps), along
   with her message. Then she uses dhbitty:
$ dhbitty encrypt bob_public_key.txt files_to_bob.tar files_to_bob.tar.dhbt
username:passphrase (this is visible!): alice:Keyfiles be damned!
Done.

   Alice sends files_to_bob.tar.dhbt to Bob. Bob will use dhbitty to decrypt \ 
this archive:
$ dhbitty decrypt files_to_bob.tar.dhbt files_to_bob.tar
username:passphrase (this is visible!): bob:Bob's Spectacular Passphrase
This is the public key of file's secondary owner:
0002f02b318c307bac07f3148a33c975cea04b79a870f0a5c7771cd38cc1986e
Done.

   Bob can verify that the public key dhbitty just gave him indeed is Alice's \ 
public key. He unpacks the now-decrypted archive to
   access the files Alice sent to him.

   In practice, Alice and Bob should use a system like diceware to pick \ 
passphrases, in order to be confident of their strength.
   Seven words picked using diceware is a good choice.