new rev compile OK

1 files changed, 59 insertions, 47 deletions

diff --git a/ecp/src/ecp/crypto/crypto.c b/ecp/src/ecp/crypto/crypto.c
index e1d06b3..66ce524 100644
--- a/ecp/src/ecp/crypto/crypto.c
+++ b/ecp/src/ecp/crypto/crypto.c
@@ -1,14 +1,17 @@
+#include <stdlib.h>
+#include <string.h>
+
 #include <core.h>
 #include <cr.h>
 
 #include <openssl/curve25519.h>
 
-int ecp_cr_dh_mkpair(ecp_dh_public_t *pub, ecp_dh_private_t *priv, ecp_rng_t rand_buf) {
+int ecp_ecdh_mkpair(ecp_ecdh_public_t *pub, ecp_ecdh_private_t *priv) {
     X25519_keypair(*pub, *priv);
     return ECP_OK;
 }
 
-int ecp_cr_dh_shsec(ecp_aead_key_t *shared, ecp_dh_public_t *pub, ecp_dh_private_t *priv) {
+int ecp_ecdh_shkey(ecp_aead_key_t *shared, ecp_ecdh_public_t *pub, ecp_ecdh_private_t *priv) {
     int rv;
 
     rv = X25519(*shared, *priv, *pub);
@@ -16,78 +19,87 @@ int ecp_cr_dh_shsec(ecp_aead_key_t *shared, ecp_dh_public_t *pub, ecp_dh_private
     return ECP_OK;
 }
 
-unsigned char *ecp_cr_dh_pub_get_buf(ecp_dh_public_t *p) {
-    return (unsigned char *)p;
+unsigned int ecp_ecdh_pub_hash(ecp_ecdh_public_t *p) {
+    return *((unsigned int *)p);
 }
 
-void ecp_cr_dh_pub_to_buf(unsigned char *b, ecp_dh_public_t *p) {
-    memcpy(b, p, ECP_ECDH_SIZE_KEY);
+int ecp_ecdh_pub_eq(ecp_ecdh_public_t *p1, ecp_ecdh_public_t *p2) {
+    return !memcmp(p1, p2, sizeof(ecp_ecdh_public_t));
 }
 
-void ecp_cr_dh_pub_from_buf(ecp_dh_public_t *p, unsigned char *b) {
-    memcpy(p, b, ECP_ECDH_SIZE_KEY);
-}
+ssize_t ecp_aead_enc(unsigned char *ct, size_t cl, unsigned char *pt, size_t pl, ecp_aead_key_t *k, ecp_nonce_t *n, unsigned char nt) {
+    ecp_aead_nonce_t nonce;
+    size_t ol;
+    int rv;
 
-int ecp_cr_dh_pub_eq(unsigned char *p1, ecp_dh_public_t *p2) {
-    return !memcmp(p1, p2, ECP_ECDH_SIZE_KEY);
-}
+    switch (nt) {
+        case ECP_NTYPE_INB:
+            memcpy(&nonce, "SRVR", 4);
+            break;
 
-unsigned int ecp_cr_dh_pub_hash_fn(unsigned char *p) {
-    return *((unsigned int *)p);
-}
+        case ECP_NTYPE_OUTB:
+            memcpy(&nonce, "CLNT", 4);
+            break;
 
-int ecp_cr_dh_pub_hash_eq(unsigned char *p1, unsigned char *p2) {
-    return !memcmp(p1, p2, ECP_ECDH_SIZE_KEY);
-}
+        case ECP_NTYPE_VBOX:
+            memcpy(&nonce, "VBOX", 4);
+            break;
 
-ssize_t ecp_cr_aead_enc(unsigned char *ct, size_t cl, unsigned char *pt, size_t pl, ecp_aead_key_t *k, unsigned char *n) {
-    uint8_t _n[ECP_AEAD_SIZE_NONCE + 4];
-    size_t ol;
-    int rv;
+        default:
+            return ECP_ERR_ENCRYPT;
+    }
+    ecp_nonce2buf((unsigned char *)&nonce + 4, n);
 
-    memset(_n, 0, 4);
-    memcpy(_n + 4, n, ECP_AEAD_SIZE_NONCE);
-    rv = aead_chacha20_poly1305_seal(*k, ECP_AEAD_SIZE_TAG, ct, &ol, cl, _n, ECP_AEAD_SIZE_NONCE + 4, pt, pl, NULL, 0);
-    if (!rv) return ECP_ERR;
+    rv = aead_chacha20_poly1305_seal(*k, ECP_SIZE_AEAD_TAG, ct, &ol, cl, (const unsigned char *)&nonce, sizeof(nonce), pt, pl, NULL, 0);
+    if (!rv) return ECP_ERR_ENCRYPT;
     return ol;
 }
 
-ssize_t ecp_cr_aead_dec(unsigned char *pt, size_t pl, unsigned char *ct, size_t cl, ecp_aead_key_t *k, unsigned char *n) {
-    uint8_t _n[ECP_AEAD_SIZE_NONCE + 4];
+ssize_t ecp_aead_dec(unsigned char *pt, size_t pl, unsigned char *ct, size_t cl, ecp_aead_key_t *k, ecp_nonce_t *n, unsigned char nt) {
+    ecp_aead_nonce_t nonce;
     size_t ol;
     int rv;
 
-    memset(_n, 0, 4);
-    memcpy(_n + 4, n, ECP_AEAD_SIZE_NONCE);
-    rv = aead_chacha20_poly1305_open(*k, ECP_AEAD_SIZE_TAG, pt, &ol, pl, _n, ECP_AEAD_SIZE_NONCE + 4, ct, cl, NULL, 0);
-    if (!rv) return ECP_ERR;
+    switch (nt) {
+        case ECP_NTYPE_INB:
+            memcpy(&nonce, "CLNT", 4);
+            break;
+
+        case ECP_NTYPE_OUTB:
+            memcpy(&nonce, "SRVR", 4);
+            break;
+
+        case ECP_NTYPE_VBOX:
+            memcpy(&nonce, "VBOX", 4);
+            break;
+
+        default:
+            return ECP_ERR_DECRYPT;
+    }
+    ecp_nonce2buf((unsigned char *)&nonce + 4, n);
+
+    rv = aead_chacha20_poly1305_open(*k, ECP_SIZE_AEAD_TAG, pt, &ol, pl, (const unsigned char *)&nonce, sizeof(nonce), ct, cl, NULL, 0);
+    if (!rv) return ECP_ERR_DECRYPT;
     return ol;
 }
 
-int ecp_cr_dsa_mkpair(ecp_dsa_public_t *pub, ecp_dsa_private_t *priv, ecp_rng_t rand_buf) {
-    unsigned char key[2*ECP_DSA_SIZE_KEY];
-
-    ED25519_keypair(*pub, key);
-    memcpy(priv, key, ECP_DSA_SIZE_KEY);
+int ecp_ecdsa_mkpair(ecp_ecdsa_public_t *pub, ecp_ecdsa_private_t *priv) {
+    ED25519_keypair(*pub, *priv);
     return ECP_OK;
 }
 
-int ecp_cr_dsa_sign(unsigned char *sig, unsigned char *m, size_t ml, ecp_dsa_public_t *p, ecp_dsa_private_t *s) {
-    unsigned char key[2*ECP_DSA_SIZE_KEY];
+int ecp_ecdsa_sign(ecp_ecdsa_signature_t *sig, unsigned char *m, size_t ml, ecp_ecdsa_private_t *k) {
     int rv;
 
-    memcpy(key, s, ECP_DSA_SIZE_KEY);
-    memcpy(key+ECP_DSA_SIZE_KEY, p, ECP_DSA_SIZE_KEY);
-
-    rv = ED25519_sign(sig, m, ml, key);
-    if (!rv) return ECP_ERR;
+    rv = ED25519_sign(*sig, m, ml, *k);
+    if (!rv) return ECP_ERR_SIGN;
     return ECP_OK;
 }
 
-int ecp_cr_dsa_verify(unsigned char *m, size_t ml, unsigned char *sig, ecp_dsa_public_t *p) {
+int ecp_ecdsa_verify(unsigned char *m, size_t ml, ecp_ecdsa_signature_t *sig, ecp_ecdsa_public_t *p) {
     int rv;
 
-    rv = ED25519_verify(m, ml, sig, *p);
+    rv = ED25519_verify(m, ml, *sig, *p);
     if (rv == 1) return ECP_OK;
-    return ECP_ERR;
+    return ECP_ERR_VERIFY;
 }