edhoc 1.4.0 → 2.0.0

package/external/libedhoc/externals/compact25519/src/c25519/sha512.c

@@ -1,230 +0,0 @@
-/* SHA512
- * Daniel Beer <dlbeer@gmail.com>, 22 Apr 2014
- *
- * This file is in the public domain.
- */
-
-#include "sha512.h"
-
-#if !defined(COMPACT_DISABLE_ED25519) || !defined(COMPACT_DISABLE_X25519_DERIVE)
-const struct sha512_state sha512_initial_state = { {
-	0x6a09e667f3bcc908LL, 0xbb67ae8584caa73bLL,
-	0x3c6ef372fe94f82bLL, 0xa54ff53a5f1d36f1LL,
-	0x510e527fade682d1LL, 0x9b05688c2b3e6c1fLL,
-	0x1f83d9abfb41bd6bLL, 0x5be0cd19137e2179LL,
-} };
-
-static const uint64_t round_k[80] = {
-	0x428a2f98d728ae22LL, 0x7137449123ef65cdLL,
-	0xb5c0fbcfec4d3b2fLL, 0xe9b5dba58189dbbcLL,
-	0x3956c25bf348b538LL, 0x59f111f1b605d019LL,
-	0x923f82a4af194f9bLL, 0xab1c5ed5da6d8118LL,
-	0xd807aa98a3030242LL, 0x12835b0145706fbeLL,
-	0x243185be4ee4b28cLL, 0x550c7dc3d5ffb4e2LL,
-	0x72be5d74f27b896fLL, 0x80deb1fe3b1696b1LL,
-	0x9bdc06a725c71235LL, 0xc19bf174cf692694LL,
-	0xe49b69c19ef14ad2LL, 0xefbe4786384f25e3LL,
-	0x0fc19dc68b8cd5b5LL, 0x240ca1cc77ac9c65LL,
-	0x2de92c6f592b0275LL, 0x4a7484aa6ea6e483LL,
-	0x5cb0a9dcbd41fbd4LL, 0x76f988da831153b5LL,
-	0x983e5152ee66dfabLL, 0xa831c66d2db43210LL,
-	0xb00327c898fb213fLL, 0xbf597fc7beef0ee4LL,
-	0xc6e00bf33da88fc2LL, 0xd5a79147930aa725LL,
-	0x06ca6351e003826fLL, 0x142929670a0e6e70LL,
-	0x27b70a8546d22ffcLL, 0x2e1b21385c26c926LL,
-	0x4d2c6dfc5ac42aedLL, 0x53380d139d95b3dfLL,
-	0x650a73548baf63deLL, 0x766a0abb3c77b2a8LL,
-	0x81c2c92e47edaee6LL, 0x92722c851482353bLL,
-	0xa2bfe8a14cf10364LL, 0xa81a664bbc423001LL,
-	0xc24b8b70d0f89791LL, 0xc76c51a30654be30LL,
-	0xd192e819d6ef5218LL, 0xd69906245565a910LL,
-	0xf40e35855771202aLL, 0x106aa07032bbd1b8LL,
-	0x19a4c116b8d2d0c8LL, 0x1e376c085141ab53LL,
-	0x2748774cdf8eeb99LL, 0x34b0bcb5e19b48a8LL,
-	0x391c0cb3c5c95a63LL, 0x4ed8aa4ae3418acbLL,
-	0x5b9cca4f7763e373LL, 0x682e6ff3d6b2b8a3LL,
-	0x748f82ee5defb2fcLL, 0x78a5636f43172f60LL,
-	0x84c87814a1f0ab72LL, 0x8cc702081a6439ecLL,
-	0x90befffa23631e28LL, 0xa4506cebde82bde9LL,
-	0xbef9a3f7b2c67915LL, 0xc67178f2e372532bLL,
-	0xca273eceea26619cLL, 0xd186b8c721c0c207LL,
-	0xeada7dd6cde0eb1eLL, 0xf57d4f7fee6ed178LL,
-	0x06f067aa72176fbaLL, 0x0a637dc5a2c898a6LL,
-	0x113f9804bef90daeLL, 0x1b710b35131c471bLL,
-	0x28db77f523047d84LL, 0x32caab7b40c72493LL,
-	0x3c9ebe0a15c9bebcLL, 0x431d67c49c100d4cLL,
-	0x4cc5d4becb3e42b6LL, 0x597f299cfc657e2aLL,
-	0x5fcb6fab3ad6faecLL, 0x6c44198c4a475817LL,
-};
-
-static inline uint64_t load64(const uint8_t *x)
-{
-	uint64_t r;
-
-	r = *(x++);
-	r = (r << 8) | *(x++);
-	r = (r << 8) | *(x++);
-	r = (r << 8) | *(x++);
-	r = (r << 8) | *(x++);
-	r = (r << 8) | *(x++);
-	r = (r << 8) | *(x++);
-	r = (r << 8) | *(x++);
-
-	return r;
-}
-
-static inline void store64(uint8_t *x, uint64_t v)
-{
-	x += 7;
-	*(x--) = v;
-	v >>= 8;
-	*(x--) = v;
-	v >>= 8;
-	*(x--) = v;
-	v >>= 8;
-	*(x--) = v;
-	v >>= 8;
-	*(x--) = v;
-	v >>= 8;
-	*(x--) = v;
-	v >>= 8;
-	*(x--) = v;
-	v >>= 8;
-	*(x--) = v;
-}
-
-static inline uint64_t rot64(uint64_t x, int bits)
-{
-	return (x >> bits) | (x << (64 - bits));
-}
-
-void sha512_block(struct sha512_state *s, const uint8_t *blk)
-{
-	uint64_t w[16];
-	uint64_t a, b, c, d, e, f, g, h;
-	int i;
-
-	for (i = 0; i < 16; i++) {
-		w[i] = load64(blk);
-		blk += 8;
-	}
-
-	/* Load state */
-	a = s->h[0];
-	b = s->h[1];
-	c = s->h[2];
-	d = s->h[3];
-	e = s->h[4];
-	f = s->h[5];
-	g = s->h[6];
-	h = s->h[7];
-
-	for (i = 0; i < 80; i++) {
-		/* Compute value of w[i + 16]. w[wrap(i)] is currently w[i] */
-		const uint64_t wi = w[i & 15];
-		const uint64_t wi15 = w[(i + 1) & 15];
-		const uint64_t wi2 = w[(i + 14) & 15];
-		const uint64_t wi7 = w[(i + 9) & 15];
-		const uint64_t s0 =
-			rot64(wi15, 1) ^ rot64(wi15, 8) ^ (wi15 >> 7);
-		const uint64_t s1 =
-			rot64(wi2, 19) ^ rot64(wi2, 61) ^ (wi2 >> 6);
-
-		/* Round calculations */
-		const uint64_t S0 = rot64(a, 28) ^ rot64(a, 34) ^ rot64(a, 39);
-		const uint64_t S1 = rot64(e, 14) ^ rot64(e, 18) ^ rot64(e, 41);
-		const uint64_t ch = (e & f) ^ ((~e) & g);
-		const uint64_t temp1 = h + S1 + ch + round_k[i] + wi;
-		const uint64_t maj = (a & b) ^ (a & c) ^ (b & c);
-		const uint64_t temp2 = S0 + maj;
-
-		/* Update round state */
-		h = g;
-		g = f;
-		f = e;
-		e = d + temp1;
-		d = c;
-		c = b;
-		b = a;
-		a = temp1 + temp2;
-
-		/* w[wrap(i)] becomes w[i + 16] */
-		w[i & 15] = wi + s0 + wi7 + s1;
-	}
-
-	/* Store state */
-	s->h[0] += a;
-	s->h[1] += b;
-	s->h[2] += c;
-	s->h[3] += d;
-	s->h[4] += e;
-	s->h[5] += f;
-	s->h[6] += g;
-	s->h[7] += h;
-}
-
-void sha512_final(struct sha512_state *s, const uint8_t *blk,
-		  size_t total_size)
-{
-	uint8_t temp[SHA512_BLOCK_SIZE] = {0};
-	const size_t last_size = total_size & (SHA512_BLOCK_SIZE - 1);
-
-	if (last_size)
-		memcpy(temp, blk, last_size);
-	temp[last_size] = 0x80;
-
-	if (last_size > 111) {
-		sha512_block(s, temp);
-		memset(temp, 0, sizeof(temp));
-	}
-
-	/* Note: we assume total_size fits in 61 bits */
-	store64(temp + SHA512_BLOCK_SIZE - 8, total_size << 3);
-	sha512_block(s, temp);
-}
-
-void sha512_get(const struct sha512_state *s, uint8_t *hash,
-		unsigned int offset, unsigned int len)
-{
-	int i;
-
-	if (offset > SHA512_BLOCK_SIZE)
-		return;
-
-	if (len > SHA512_BLOCK_SIZE - offset)
-		len = SHA512_BLOCK_SIZE - offset;
-
-	/* Skip whole words */
-	i = offset >> 3;
-	offset &= 7;
-
-	/* Skip/read out bytes */
-	if (offset) {
-		uint8_t tmp[8];
-		unsigned int c = 8 - offset;
-
-		if (c > len)
-			c = len;
-
-		store64(tmp, s->h[i++]);
-		memcpy(hash, tmp + offset, c);
-		len -= c;
-		hash += c;
-	}
-
-	/* Read out whole words */
-	while (len >= 8) {
-		store64(hash, s->h[i++]);
-		hash += 8;
-		len -= 8;
-	}
-
-	/* Read out bytes */
-	if (len) {
-		uint8_t tmp[8];
-
-		store64(tmp, s->h[i]);
-		memcpy(hash, tmp, len);
-	}
-}
-#endif

package/external/libedhoc/externals/compact25519/src/c25519/sha512.h

@@ -1,54 +0,0 @@
-/* SHA512
- * Daniel Beer <dlbeer@gmail.com>, 22 Apr 2014
- *
- * This file is in the public domain.
- */
-
-#ifndef SHA512_H_
-#define SHA512_H_
-
-#if !defined(COMPACT_DISABLE_ED25519) || !defined(COMPACT_DISABLE_X25519_DERIVE)
-#include <stdint.h>
-#include <stddef.h>
-#include <string.h>
-
-/* SHA512 state. State is updated as data is fed in, and then the final
- * hash can be read out in slices.
- *
- * Data is fed in as a sequence of full blocks terminated by a single
- * partial block.
- */
-struct sha512_state {
-	uint64_t  h[8];
-};
-
-/* Initial state */
-extern const struct sha512_state sha512_initial_state;
-
-/* Set up a new context */
-static inline void sha512_init(struct sha512_state *s)
-{
-	memcpy(s, &sha512_initial_state, sizeof(*s));
-}
-
-/* Feed a full block in */
-#define SHA512_BLOCK_SIZE  128
-
-void sha512_block(struct sha512_state *s, const uint8_t *blk);
-
-/* Feed the last partial block in. The total stream size must be
- * specified. The size of the block given is assumed to be (total_size %
- * SHA512_BLOCK_SIZE). This might be zero, but you still need to call
- * this function to terminate the stream.
- */
-void sha512_final(struct sha512_state *s, const uint8_t *blk,
-		  size_t total_size);
-
-/* Fetch a slice of the hash result. */
-#define SHA512_HASH_SIZE  64
-
-void sha512_get(const struct sha512_state *s, uint8_t *hash,
-		unsigned int offset, unsigned int len);
-
-#endif
-#endif

package/external/libedhoc/externals/compact25519/src/compact_ed25519.c

@@ -1,46 +0,0 @@
-#include "compact_ed25519.h"
-
-#ifndef COMPACT_DISABLE_ED25519
-#include "c25519/edsign.h"
-#include "compact_wipe.h"
-#include <string.h>
-
-#define __PUBLIC_KEY_OFFSET (32)
-
-void compact_ed25519_keygen(
-    uint8_t private_key[ED25519_PRIVATE_KEY_SIZE], 
-    uint8_t public_key[ED25519_PUBLIC_KEY_SIZE], 
-    uint8_t random_seed[ED25519_SEED_SIZE]
-) {
-    // private key is seed + public key, like golang and others
-    edsign_sec_to_pub(public_key, random_seed);
-    memcpy(private_key, random_seed, ED25519_SEED_SIZE);
-    memcpy(private_key + __PUBLIC_KEY_OFFSET, public_key, ED25519_PUBLIC_KEY_SIZE);
-    compact_wipe(random_seed, ED25519_SEED_SIZE);
-}
-
-void compact_ed25519_calc_public_key(
-    uint8_t public_key[ED25519_PUBLIC_KEY_SIZE], 
-    const uint8_t private_key[ED25519_PRIVATE_KEY_SIZE]
-) {
-    memcpy(public_key, private_key + __PUBLIC_KEY_OFFSET, ED25519_PUBLIC_KEY_SIZE);
-}
-
-void compact_ed25519_sign(
-    uint8_t signature[ED25519_SIGNATURE_SIZE], 
-    const uint8_t private_key[ED25519_PRIVATE_KEY_SIZE], 
-    const void *message, 
-    size_t msg_length
-) {
-    edsign_sign(signature, private_key + __PUBLIC_KEY_OFFSET, private_key, message, msg_length);
-}
-
-bool compact_ed25519_verify(
-    const uint8_t signature[ED25519_SIGNATURE_SIZE], 
-    const uint8_t public_key[ED25519_PUBLIC_KEY_SIZE], 
-    const void *message, 
-    size_t msg_length
-) {
-    return edsign_verify(signature, public_key, message, msg_length) != 0;
-}
-#endif

package/external/libedhoc/externals/compact25519/src/compact_ed25519.h

@@ -1,110 +0,0 @@
-#ifndef _COMPACT_ED25519_H
-#define _COMPACT_ED25519_H
-
-#ifndef COMPACT_DISABLE_ED25519
-/*
- Ed25519 signs messages using Curve25519.
- 
- After pre-sharing a public key, it allows two parties to verify the other side
- is who they say they are and that the communication is not altered.
- 
- A signature is a ED25519_SIGNATURE_SIZE size byte array that can be only be 
- generated when you have the private key, but can be verified if you have 
- the public key. 
- 
- As an example: two parties want to have rotating keys for their encryption.
- The only thing they need to know about eachother is their long term Ed25519
- public key. Per session they perform a X25519 key exchange, but sign their 
- "Ephemeral" public key with their long-term Ed25519 private key. Now they can 
- share this public key (and the signature) over a cleartext channel, nobody can
- alter of impersonate this exchange.
- 
- (this is roughly how TLS works)
-*/
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#define ED25519_SEED_SIZE (32)
-#define ED25519_PUBLIC_KEY_SIZE (32)
-#define ED25519_PRIVATE_KEY_SIZE (64)
-#define ED25519_SIGNATURE_SIZE (64)
-
-/*
- Generate a private signing key from a random seed.
- 
- input:
-     - random_seed = random bytes that need to be filled from a good source of 
-         random entropy, PLEASE research the options on your platform!
- 
- output:
-     - private_key = signing key than can be used for compact_ed25519_sign
-     - public_key = key to share with other parties 
- 
- (internally the format of the private key is the seed + public key, 
- this makes it compatible with keys coming from libsodium, golang, and 
- implentations that derive from SUPERCOP/ref10)
-*/
-void compact_ed25519_keygen(
-    uint8_t private_key[ED25519_PRIVATE_KEY_SIZE], 
-    uint8_t public_key[ED25519_PUBLIC_KEY_SIZE], 
-    uint8_t random_seed[ED25519_SEED_SIZE]
-);
-
-/*
- Extract public key from private key
- 
- input:
-     - private_key = signing key generated with compact_ed25519_keygen
- 
- output:
-     - public_key = public key corresponding to this private key, share with
-         interested parties
-*/
-void compact_ed25519_calc_public_key(
-    uint8_t public_key[ED25519_PUBLIC_KEY_SIZE], 
-    const uint8_t private_key[ED25519_PRIVATE_KEY_SIZE]
-);
-
-/*
- Sign a message with the private key.
- 
- input:
-     - private_key = signing key generated with compact_ed25519_keygen or from a
-         compatible source
-     - message = pointer to the data that needs to be signed
-     - msg_length = how many bytes to read from the start of the message pointer
- output:
-     - signature = the signature that proves you hold the private key and that
-         nobody tried to change the message. (the second property only holds
-         if the attacker cannot change the size of the message)
-*/
-void compact_ed25519_sign(
-    uint8_t signature[ED25519_SIGNATURE_SIZE], 
-    const uint8_t private_key[ED25519_PRIVATE_KEY_SIZE], 
-    const void *message, 
-    size_t msg_length
-);
-
-/*
- Verify a signature against a public key.
- 
- input:
-     - signature = which signature to verify
-     - public_key = the public key that it should be verified against 
-         (should not have been part of the message that contained the signature)
-     - message = message to verify
-     - msg_length = size of the message to verify
- 
- returns:
-     true if verified
-*/
-bool compact_ed25519_verify(
-    const uint8_t signature[ED25519_SIGNATURE_SIZE], 
-    const uint8_t public_key[ED25519_PUBLIC_KEY_SIZE], 
-    const void *message, 
-    size_t msg_length
-);
-#endif
-
-#endif

package/external/libedhoc/externals/compact25519/src/compact_wipe.c

@@ -1,12 +0,0 @@
-#include "compact_wipe.h"
-#include <stdlib.h>
-#include <string.h>
-
-void *compact_wipe(void *data, size_t length) {
-// simplification of: https://www.cryptologie.net/article/419/zeroing-memory-compiler-optimizations-and-memset_s/
-	 volatile unsigned char *p = data;
-	 while (length--){
-		 *p++ = 0;
-	 }
-	return data;
-}

package/external/libedhoc/externals/compact25519/src/compact_wipe.h

@@ -1,14 +0,0 @@
-#ifndef __COMPACT_WIPE_H
-#define __COMPACT_WIPE_H
-#include <stdint.h>
-#include <stddef.h>
-/*
-    Try to wipe contents of a buffer, as best as we can.
-    (memset can be ignored by the compiler)
-
-    Use this to clear private key data if you do not need it anymore.
-
-    returns the data pointer, makes for easier chaining
-*/
-void *compact_wipe(void *data, size_t length);
-#endif

package/external/libedhoc/externals/compact25519/src/compact_x25519.c

@@ -1,68 +0,0 @@
-
-#ifndef COMPACT_DISABLE_X25519
-#include "compact_x25519.h"
-#include "c25519/c25519.h"
-#include "c25519/sha512.h"
-#include "compact_wipe.h"
-
-void compact_x25519_keygen(
-    uint8_t private_key[X25519_KEY_SIZE], 
-    uint8_t public_key[X25519_KEY_SIZE],
-    uint8_t random_seed[X25519_KEY_SIZE]
-) {
-    memcpy(private_key, random_seed, X25519_KEY_SIZE);
-    compact_wipe(random_seed, X25519_KEY_SIZE);
-    c25519_prepare(private_key);
-    c25519_smult(public_key, c25519_base_x, private_key);
-}
-
-void compact_x25519_shared(
-    uint8_t shared_secret[X25519_SHARED_SIZE], 
-    const uint8_t my_private_key[X25519_KEY_SIZE], 
-    const uint8_t their_public_key[X25519_KEY_SIZE]
-) {
-    // Ensure that supplied private key is clamped (fix issue #1).
-    // Calling `c25519_prepare` multiple times for the same private key
-    // is OK because it won't modify already clamped key.
-    uint8_t clamped_private_key[X25519_KEY_SIZE];
-    memcpy(clamped_private_key, my_private_key, X25519_KEY_SIZE);
-    c25519_prepare(clamped_private_key);
-    c25519_smult(shared_secret, their_public_key, clamped_private_key);
-    compact_wipe(clamped_private_key, X25519_KEY_SIZE);
-}
-
-#ifndef COMPACT_DISABLE_X25519_DERIVE
-#if (X25519_KEY_SIZE + (2 * X25519_KEY_SIZE)) > SHA512_BLOCK_SIZE 
-#error "Unexpected key sizes"
-#endif
-
-static uint8_t* append(uint8_t *dst, const void * source, size_t length) {
-    memcpy(dst, source, length);
-    return dst + length;
-}
-
-void compact_x25519_derive_encryption_key(
-    uint8_t *encryption_key, 
-    size_t key_size, 
-    const uint8_t shared_secret[X25519_SHARED_SIZE], 
-    const uint8_t public_key1[X25519_KEY_SIZE], 
-    const uint8_t public_key2[X25519_KEY_SIZE]
-) {
-    if (key_size > SHA512_HASH_SIZE) {
-        key_size = SHA512_HASH_SIZE;
-    }
-    uint8_t key_data[X25519_SHARED_SIZE + 2 * X25519_KEY_SIZE];
-    uint8_t *p = key_data;
-    p = append(p, shared_secret, X25519_SHARED_SIZE);
-    p = append(p, public_key1, X25519_KEY_SIZE);
-    append(p, public_key2, X25519_KEY_SIZE);
-
-    struct sha512_state hasher;
-    sha512_init(&hasher);
-    sha512_final(&hasher, key_data, sizeof(key_data));
-    sha512_get(&hasher, encryption_key, 0, key_size);
-
-    compact_wipe(key_data, X25519_SHARED_SIZE); // clear the session key at least
-}
-#endif
-#endif

package/external/libedhoc/externals/compact25519/src/compact_x25519.h

@@ -1,101 +0,0 @@
-#ifndef _COMPACT_X25519_H
-#define _COMPACT_X25519_H
-
-#ifndef COMPACT_DISABLE_X25519
-/* 
- X25519 is a DH key exchange over Curve25519.
- 
- Two parties can share their public keys over an open channel and agree upon 
- a shared secret, that a third party cannot derive.
- 
- Security concern: if a third party can intercept and change your connection in 
- some way, then X25519 is not enough. The third party could for example run 
- two X25519 sessions, one between themselfs and you, and another one between 
- themselfs and the server. X25519 has no protection against this.
- 
- A possible solution is to use Ed25519 to sign the public keys exchanged, with a 
- special set of keys that is known before hand. Depending on your scenario, this 
- either means embedding a set of long-term keys in your application or setting up 
- some kind of Public Key Infrastructure (PKI).
- 
- If that sounds to complicated or would not work for your case, checkout 
- the Noise framework. It is a bit less compact than X25519 + Ed25519 but much 
- more flexible in the kind of session setup styles.
-*/
-
-#include <stddef.h>
-#include <stdint.h>
-
-#define X25519_KEY_SIZE (32)
-#define X25519_SHARED_SIZE (32)
-
-/*
- Calculate public & private keypair for X25519 key exchange. 
- Never transmit the private_key!
- 
- input:
-     - random_seed = random bytes that need to be filled from a good source of 
-         random entropy, PLEASE research the options on your platform!
- 
- output:
-     - private_key = resulting private key, never share this with the other party
-     - public_key = public key to be shared with the other party
-*/
-void compact_x25519_keygen(
-    uint8_t private_key[X25519_KEY_SIZE], 
-    uint8_t public_key[X25519_KEY_SIZE],
-    uint8_t random_seed[X25519_KEY_SIZE]
-);
-
-/*
- Calculate shared secret based on the others side public key.
- The shared secret does not have a uniform distribution so common advice 
- is to avoid using it directly as a key. You can use 
- compact_x25519_derive_encryption_key to get a more suitable encryption 
- key out of this shared secret
- 
- input:
-     - my_private_key = private key that came out of compact_x25519_keygen
-     - their_public_key = public key that was shared by the other party
- 
- output:
-     - shared_secret = X25519_SHARED_SIZE bytes that both sides now share 
-*/
-void compact_x25519_shared(
-    uint8_t shared_secret[X25519_SHARED_SIZE], 
-    const uint8_t my_private_key[X25519_KEY_SIZE], 
-    const uint8_t their_public_key[X25519_KEY_SIZE]
-);
-
-#ifndef COMPACT_DISABLE_X25519_DERIVE
-/*
- Derive an more suitable encryption key from the shared secret.
- This is not part of the normal X25519 specification, but the specifications 
- does warn that the shared secret is less suited as symmetric encryption key.
- 
- The encryption key is the result of 
- sha512(concat(shared_secret, public_key1, public_key2))[0..key_size]
- 
- You have to make sure both parties agree which public key goes in first.
- 
- input:
-     - key_size = number between 1 and 64, of how big your encryption_key 
-         needs to be, make sure there is enough room where 
-         the encryption_key points to
-     - shared_secret = result of compact_x25519_shared
-     - public_key1 = first public key to mix in with the key
-     - public_key2 = second public key to mix in with the key
- 
- output:
-     - encryption_key = supplied buffer is filled with a encryption key
-*/
-void compact_x25519_derive_encryption_key(
-    uint8_t *encryption_key, 
-    size_t key_size, 
-    const uint8_t shared_secret[X25519_SHARED_SIZE], 
-    const uint8_t public_key1[X25519_KEY_SIZE], 
-    const uint8_t public_key2[X25519_KEY_SIZE]
-);
-#endif
-#endif
-#endif

package/external/libedhoc/externals/compact25519/test/pcg_random.h

@@ -1,25 +0,0 @@
-#ifndef PCG_RANDOM_H
-#define PCG_RANDOM_H
-
-// WARNING: this is a BAD source for random data for this library
-// it is only used as an easy way to make the tests more cross platform.
-// Good randomness is platform specific, PLEASE USE THAT SOURCE, NOT THIS
-
-
-// *Really* minimal PCG32 code / (c) 2014 M.E. O'Neill / pcg-random.org
-// Licensed under Apache License 2.0 (NO WARRANTY, etc. see website)
-
-#include <stdint.h>
-typedef struct { uint64_t state;  uint64_t inc; } pcg32_random_t;
-
-static uint32_t pcg32_random_r(pcg32_random_t* rng)
-{
-    uint64_t oldstate = rng->state;
-    // Advance internal state
-    rng->state = oldstate * 6364136223846793005ULL + (rng->inc|1);
-    // Calculate output function (XSH RR), uses old state for max ILP
-    uint32_t xorshifted = ((oldstate >> 18u) ^ oldstate) >> 27u;
-    uint32_t rot = oldstate >> 59u;
-    return (xorshifted >> rot) | (xorshifted << ((-rot) & 31));
-}
-#endif