s/dangerous/dirty

Those functions are not that dangerous, and such a scary word
would send the wrong message.  The manual though will make clear
this is not for everyone

Forgot to wipe buffers

Added dangerous X25519 speed benchmarks

Merge pull request #161 from fscoto/master+new-doc

doc: contributory behavior may be required sometimes

doc: contributory behavior may be required sometimes

While already there, hoist the explanation about contributory behavior
from RETURN VALUES to the main DESCRIPTION section.
The only reason it was in RETURN VALUES is because of historical
reasons; we used to justify why the return value was deprecated there,
so the position of the explanation made sense before removal of the
return value.

Refined the Elligator interface

Also added a new lightweight (but slower) path for embedded devices

Elligator script: alternate way to co-clear

Have trim_scalar() copy its own buffer

Commented inverse square root

Elligator script: simplified Montgomery ladder

Renamed Elligator2 functions

Save more LOC with load/store routines

More honest LOC count for scalarmult

Added ZERO helper to save some more lines

Added COPY helper to save some LOC

Note: we generally copy bytes, maybe it could be a function...

Added scalar multiplication by inverse

Elligator script: added padding to test vectors

So we properly test Monocypher ignores the padding

Elligator script: small refactor

Added vectors from hash_to_curve RFC

Elligator: take cofactor from secret key instead of tweak

This allows the simplification of the implementation of higher level
interfaces.

The idea is, only the scalar and cofactor have any influence over
whether the inverse map succeeds or fail. This means that when it fails,
the padding & sign have not be used at all, and can be "reused" to
generate another random seed.

In practice, this means we can use Chacha20 or Blake2, or any hash that
outputs 64 random bytes from 32 random bytes, use 32 bytes to make an
attempt, then use the *other* 32 bytes to either generate more random
bytes (if we failed), or to use the tweak (if we succeed).

The tweak has also been modified to simplify the implementation. The
sign bit is now the least significant bit, and the padding bits are the
most significant bits. The computational savings are negligible, but
this allows neat micro-simplifications.

Added easy interface for Elligator

Note a small problem in the implementation: we are reusing one byte for
both the tweak and the next random seed.  This makes them *not*
independent, and a possible source of vulnerability.

In practice, this is only a problem for the 3 bits comprising the
cofactor, since the sign and the padding do not play a role in deciding
whether the mapping fails or succeeds.

TODO: take the cofactor from the clamped bits of the scalar, instead of
the tweak. This will ensure proper independence, while keeping the high
level code simple and maximally efficient.

Don't try to re-generate test vectors upon release

Ignore the right release script

Minor bits & fixes

Commented how clamping biases Elligator keys

Elligator/X25519 compatibility test

Whitespace nitpick

Elligator Script: fixed short test vectors

Overlapping tests for Elligator2 (inverse)

Added Elligator2 inverse mapping

Removed temporary to save some more stack

Forgot to wipe a buffer

Comment nitpick

Separated EdDSA parsing and negation

The goal is to make the code easier to understand.  Merging parsing and
negation was clever, but it also was confusing.  Better not be clever.

The cost is 2 field negations. Arguably negligible.

Simplified Edwards point parsing

Elligator tests: overlapping I/O

Elligator script: removed unused imports

git ignore __pycache__

Typo, comment fe_isnegative()

Elligator: fixed failure to ignore padding

Added tests for Elligator direct mappings

Fixed broken compilation

Elligator script: removed unnecessary temporary

Added Elligator2 direct map

Merge pull request #158 from fscoto/master+randombytes

Add random_bytes() to crypto_lock examples

crypto_sign example: sign the *entire* message

extract_examples.sh: warning cleanup

1. Remove now-unused random_bytes().
2. "warning: empty struct has size 0 in C, size 1 in C++ [-Wc++-compat]"
   "warning: empty struct is a GNU extension [-Wgnu-empty-struct]"
   clang -Weverything

Merge branch 'master' into master+randombytes

crypto_sha512 example overhaul

Just gives it a message to hash, matching crypto_blake2b(3monocypher).
Nothing to randomize.

crypto_hmac_sha512 example overhaul

1. Randomize the key.
2. Key for HMAC is NOT optional.
3. Give it an actual example message to authenticate.

crypto_x25519 example overhaul

Just adds arc4random_buf().

crypto_sign example overhaul

1. Randomize key.
2. Give it an actual example message to sign.

crypto_poly1305 example overhaul

1. Randomize key.
2. Give it an actual example message to MAC.

crypto_key_exchange example overhaul

Just adds arc4random_buf().

crypto_hchacha20 example overhaul

Just adds arc4random_buf() for the key.

crypto_chacha20 example overhaul

1. Randomize keys and nonces.
2. Minor alignment fix in second example.
3. Make i unsigned to avoid clang warning about 500-(i-64) changing
   signedness with -Weverything.
4. Initialize ctr to 0.
5. Fix obviously wrong encryption by jumping around example
   (repeating ctr issue [!], wrong function used in the example).

crypto_blake2b example overhaul

1. A key when "Computing a message authentication code" is NOT optional.
2. Randomize keys.

crypto_argon2i example overhaul

1. The common type for a password is char*; use a cast instead.
   C11, para. 6.5(7) suggests this will be largely okay.
2. Wipe the password on failure.
3. Initialize the password size while there.
   Does not use strlen(3) to avoid extra stdlib functions.
4. Branch on allocation failure.

Elligator script: clean up & comments

Another attempt at crypto_lock example overhaul

Merge pull request #160 from fscoto/master+test-typo

tests: fix typo in messages

tests: fix typo in messages

Merge pull request #159 from richwalm/master

Document & test overlapping of key_exchange.

Perform a full overlapping range for test.

Also done the same for x25519 and included copyright details.

Document & test overlapping of key_exchange.

Elligator script: added paper URL

Add random_bytes() to crypto_lock examples

Elligator script: comments & proofs

Elligator script: general organisation

Elligator script: removed slow scalarmult

Elligator script: clarified non-square

Elligator Script: ackwowledge Andrew Moon's contribution

Replaced fast mappings by even better ones

Turned out there were much simpler ways to compute the mapping, thanks
to the fact that when the prime p is congruent to 5 modulo 8, we have
this nice equality:

    x^((p-5)/8) = sqrt(1/x)          if x is square,
    x^((p-5)/8) = sqrt(sqrt(-1)/x)   otherwise

The code was kindly given by Andrew Moon, who got the original trick
from Mike Hamburg.

Merge pull request #157 from fscoto/master+examples

Examples: const correctness

Examples: const correctness

It's unfortunate that we can't both tell users to wipe keys and
illustrate which arguments are inputs and which ones are outputs
at the same time, but that's just how it is.

Elligator scritp: positive/negative cosmetic

Elligator script: hoisted constant out

Elligator script: added explicit curve to hash

Now we can finally begin the C implementation, which should be a
straightforward transliteration of the Python code.

Man page: fixed const in code example

Elligator script: whitespace nitpick

Added Elligator to vector generation

vector_to_header now handles leading empty lines

README.md: fixed test dir path

Elligator script: ordering nitpick

Elligator script: take vectors from stdin

Elligator script: added fast_curve_to_hash

Elligator script: test explicit_hash_to_curve

Elligator script: remove redundant test

Elligator script: test fast_scalarbase

Elligator script: moved final tests

Elligator script: naming nitpick

Elligator script: use x25519_pk test vectors

We're now reading the `x25519_pk.all.vec` generated by Libsodium in
`x25519.c`, to make sure scalarmult is correctly implemented in the
Python script.

While we're at it, we also use them to generate Elligator 2 vectors.
Any addition to the X25519 public key generation will automatically
benefit Elligator 2 as well

TODO: update the makefile to make sure the vectors are generated before
we run `elligator.py`

Elligator script: avoid redundant computaton

Elligator script: added fast_from_edwards

Elligator script: readability nitpick

The can_curve_to_hash() test takes a Montgomery point as input, whose
coordinates are generally called (u, v), not (x, y).

Elligator script: removed erroneous .abs()

Changing the sign of the v coordinate had an effect on the final value
of the final hash, but wasn't detected because my initial tests only
compare to the u coordinate, which appears to be correct.

This doesn't affect the success or failure of the Elligator mapping,
which only look at the u coordinate.  Yet another example of incorrect
crypto that looks like it works...

Elligator 2 script: fast scalarmult, explicit hash_to_curve

The fast scalar multiplication will let us explore the merging of the
various exponentiations required to perform the conversion to Montgomery
then curve_to_hash.

The explicit hash_to_curve() serves as an implementation guide.  Note
the omission of the v coordinate, not needed for X25519.  I am not
aware of a compelling use case to convert to Edwards (not all PAKEs need
point addition).

Added the fe (field element) type for readability

Having to write those modulo operators everywhere was tiresome. Having
an explicit field element type allows a more direct writing. It also
helps Python throw type errors if we misuse anything.

Portability nitpick

Use pow() for exponentiation in Python 3

Much faster this way.