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.

Simplified elligator scripts a bit

Add license to elligator script

Ported SAGE script to Python3

Turned out SAGE wasn't really needed. Python already has all we need,
and the differences are minimal.  Cryptographers will be able to read
the Python code as easily as SAGE.

The disadvantage is that Python3's arithmetic is twice as slow.
The advantage is that Python3 is ubiquitous, and can reasonably be
required to generate test vectors.

SAGE script: use (and fix) scalarbase

SAGE script: removed dead code

Python 3 compatible print calls for SAGE

Added Elligator2 SAGE script

That script prints test vectors to the standard output, in the following
order:

- private key
- public key (X coordinate)
- public key (Y coordinate, never exposed by Monocypher)
- Boolean (0 if we can't convert, 1 if we can)
- hash of the public key (or zero if we couldn't convert)

I could use that script to generate the test vectors automatically, but
I hesitate to introduce a hard dependency on SAGE.

The alternative is to put the test vectors themselves under version
control.  We could add a target to the makefile that checks whether the
test vectors and the script are in sync, but that would break if we end
up adding vectors manually (which typically happens whenever project
Whycheproof publishes new vectors).

Removed modulo operation in SHA-512

While I expect almost all compilers optimise those down to a bit mask in
practice, it can help naive compilers generate better code. The rest of
Monocypher already took this approach, I just forgot about this one.

Removed 64-bit modulo operation in Argon2i

Fixes #156

This modulo operation is implemented on software in many 32-bits
processors, such as the Cortex-M3.  This causes the generated binary to
depend a standard library routine that is often not present on such
small machines.  This hurts portability and convenience.

Thankfully, this particular modulo is not needed, and can be replaced by
a simple test and subtraction. This is not constant time, but we don't
care: the index we are computing does not depend on any secret, so a
variable timing won't expose anything.

Performance seems to very slightly increase on x86-64. 32-bit machines
may benefit more.

Removed unnecesary period in HMAC manual

Added warning in the Git version of the README

I noticed that some careless hurried people tend to use Monocypher from
the git repository directly. They don't even grab the releases from
GitHub.  That's not ideal for two reasons:

1. The master branch isn't always stable.
2. The Git repository misses some automatically generated files.

This patch attempts to get end users away from the Git repository,
towards well tested official releases.  Also, for users who think the
tarball are binary releases (they're source releases), or just want to
be done as quickly as possible, I also gave direct links to the main
source and header files.

Minor man page nitipick

Merge pull request #155 from fscoto/master+pwhash-doc

Be more explicit about passwords in man pages

pw hashing: clarify that hash functions can hash

Misleading wording spotted by @aggsol as part of review of #155.

Be more explicit about passwords in man pages

Prompted by an inquiry in #154.

Improved readability of EdDSA verification

Basically, we separated the computation of R_check from the verification
that it is equal to R. The computation of R_check takes s, h_ram and the
public key as parameter, and output R_check.

The primary advantage is a better separation of concerns, which makes
the code more readable in my opinion.

A secondary advantage is that we could now test ge_r_check() separately,
with arbitrary values of s and h_ram.  This lets us test difficult to
trigger edge cases, like having s or h_ram exceeding 2^252, and is just
plain more general than only testing valid and invalid signatures.

I very much like this secondary advantage, because EdDSA is to this day
the part of Monocypher that makes me the most nervous.

Easier to use ge_madd() and ge_msub()

There are two main changes:

1. ge_madd() and ge_msub() now take a ge_precomp as second argument.
2. ge_msub() can now process secrets.

The pre-computed table have been adjusted accordingly. They're now
arrays of ge_precomp instead of being multiple arrays of fe.

We can also expect a (mostly negligible) performance increase:

- The new tables have slightly better locality.
- ge_msub() is the mirror of ge_madd() instead of using it.
- Using ge_msub() for signatures is now slightly more direct.

Corrected changelog (IETF Chacha20)

Can't correct the tarball itself (that's a hash set in stone), but the
repository and Github releases can be changed, at least.

vector_to_header did not return 0

Update Changelog date

Merge pull request #151 from fscoto/master+comments

Add some comments about what the EC functions do

Add some comments about what the EC functions do

This hopefully helps both auditing the code (by giving a clear
indication of what a function is supposed to be doing),
and trying to work with it (by minimizing the amount of time people need
to determine if a function is relevant to their interests).

Bump copyright year (again)

Bump copyright year

Fixed missing wipe

And a few cosmetics

Removed unnecessary wipe