#include "dnscrypt/cert.h"
#include "dnscrypt/dnscrypt.h"
+#include "dnscrypt/dnscrypt_config.h"
#include <ctype.h>
(DNSCRYPT_MAGIC_HEADER_LEN + crypto_box_HALF_NONCEBYTES + crypto_box_HALF_NONCEBYTES)
/**
- * Decrypt a query using the keypair that was found using dnsc_find_keypair.
+ * Decrypt a query using the dnsccert that was found using dnsc_find_cert.
* The client nonce will be extracted from the encrypted query and stored in
* client_nonce, a shared secret will be computed and stored in nmkey and the
* buffer will be decrypted inplace.
- * \param[in] keypair the keypair that matches this encrypted query.
+ * \param[in] cert the cert that matches this encrypted query.
* \param[in] client_nonce where the client nonce will be stored.
* \param[in] nmkey where the shared secret key will be written.
* \param[in] buffer the encrypted buffer.
* \return 0 on success.
*/
static int
-dnscrypt_server_uncurve(const KeyPair *keypair,
+dnscrypt_server_uncurve(const dnsccert *cert,
uint8_t client_nonce[crypto_box_HALF_NONCEBYTES],
uint8_t nmkey[crypto_box_BEFORENMBYTES],
struct sldns_buffer* buffer)
query_header = (struct dnscrypt_query_header *)buf;
memcpy(nmkey, query_header->publickey, crypto_box_PUBLICKEYBYTES);
- if (crypto_box_beforenm(nmkey, nmkey, keypair->crypt_secretkey) != 0) {
+ if(cert->es_version[1] == 2) {
+#ifdef HAVE_XCHACHA20
+ if (crypto_box_curve25519xchacha20poly1305_beforenm(
+ nmkey, nmkey, cert->keypair->crypt_secretkey) != 0) {
+ return -1;
+ }
+#else
return -1;
+#endif
+ } else {
+ if (crypto_box_beforenm(nmkey, nmkey, cert->keypair->crypt_secretkey) != 0) {
+ return -1;
+ }
}
memcpy(nonce, query_header->nonce, crypto_box_HALF_NONCEBYTES);
memset(nonce + crypto_box_HALF_NONCEBYTES, 0, crypto_box_HALF_NONCEBYTES);
- sldns_buffer_set_at(buffer,
- DNSCRYPT_QUERY_BOX_OFFSET - crypto_box_BOXZEROBYTES,
- 0, crypto_box_BOXZEROBYTES);
-
- if (crypto_box_open_afternm
- (buf + DNSCRYPT_QUERY_BOX_OFFSET - crypto_box_BOXZEROBYTES,
- buf + DNSCRYPT_QUERY_BOX_OFFSET - crypto_box_BOXZEROBYTES,
- len - DNSCRYPT_QUERY_BOX_OFFSET + crypto_box_BOXZEROBYTES, nonce,
- nmkey) != 0) {
+ if(cert->es_version[1] == 2) {
+#ifdef HAVE_XCHACHA20
+ if (crypto_box_curve25519xchacha20poly1305_open_easy_afternm
+ (buf,
+ buf + DNSCRYPT_QUERY_BOX_OFFSET,
+ len - DNSCRYPT_QUERY_BOX_OFFSET, nonce,
+ nmkey) != 0) {
+ return -1;
+ }
+#else
return -1;
+#endif
+ } else {
+ if (crypto_box_open_easy_afternm
+ (buf,
+ buf + DNSCRYPT_QUERY_BOX_OFFSET,
+ len - DNSCRYPT_QUERY_BOX_OFFSET, nonce,
+ nmkey) != 0) {
+ return -1;
+ }
}
+ len -= DNSCRYPT_QUERY_HEADER_SIZE;
+
while (*sldns_buffer_at(buffer, --len) == 0)
;
}
memcpy(client_nonce, nonce, crypto_box_HALF_NONCEBYTES);
- memmove(sldns_buffer_begin(buffer),
- sldns_buffer_at(buffer, DNSCRYPT_QUERY_HEADER_SIZE),
- len - DNSCRYPT_QUERY_HEADER_SIZE);
sldns_buffer_set_position(buffer, 0);
- sldns_buffer_set_limit(buffer, len - DNSCRYPT_QUERY_HEADER_SIZE);
+ sldns_buffer_set_limit(buffer, len);
return 0;
}
}
/**
- * Encrypt a reply using the keypair that was used with the query.
+ * Encrypt a reply using the dnsccert that was used with the query.
* The client nonce will be extracted from the encrypted query and stored in
* The buffer will be encrypted inplace.
- * \param[in] keypair the keypair that matches this encrypted query.
+ * \param[in] cert the dnsccert that matches this encrypted query.
* \param[in] client_nonce client nonce used during the query
* \param[in] nmkey shared secret key used during the query.
* \param[in] buffer the buffer where to encrypt the reply.
* \return 0 on success.
*/
static int
-dnscrypt_server_curve(const KeyPair *keypair,
+dnscrypt_server_curve(const dnsccert *cert,
uint8_t client_nonce[crypto_box_HALF_NONCEBYTES],
uint8_t nmkey[crypto_box_BEFORENMBYTES],
struct sldns_buffer* buffer,
memmove(boxed + crypto_box_MACBYTES, buf, len);
len = dnscrypt_pad(boxed + crypto_box_MACBYTES, len,
max_len - DNSCRYPT_REPLY_HEADER_SIZE, nonce,
- keypair->crypt_secretkey);
+ cert->keypair->crypt_secretkey);
sldns_buffer_set_at(buffer,
DNSCRYPT_REPLY_BOX_OFFSET - crypto_box_BOXZEROBYTES,
0, crypto_box_ZEROBYTES);
// add server nonce extension
add_server_nonce(nonce);
- if (crypto_box_afternm
- (boxed - crypto_box_BOXZEROBYTES, boxed - crypto_box_BOXZEROBYTES,
- len + crypto_box_ZEROBYTES, nonce, nmkey) != 0) {
+ if(cert->es_version[1] == 2) {
+#ifdef HAVE_XCHACHA20
+ if (crypto_box_curve25519xchacha20poly1305_easy_afternm
+ (boxed, boxed + crypto_box_MACBYTES, len, nonce, nmkey) != 0) {
+ return -1;
+ }
+#else
return -1;
+#endif
+ } else {
+ if (crypto_box_easy_afternm
+ (boxed, boxed + crypto_box_MACBYTES, len, nonce, nmkey) != 0) {
+ return -1;
+ }
}
sldns_buffer_write_at(buffer, 0, DNSCRYPT_MAGIC_RESPONSE, DNSCRYPT_MAGIC_HEADER_LEN);
}
/**
- * Find the keypair matching a DNSCrypt query.
- * \param[in] dnscenv The DNSCrypt enviroment, which contains the list of keys
+ * Find the cert matching a DNSCrypt query.
+ * \param[in] dnscenv The DNSCrypt enviroment, which contains the list of certs
* supported by the server.
* \param[in] buffer The encrypted DNS query.
- * \return a KeyPair * if we found a key pair matching the query, NULL otherwise.
+ * \return a dnsccert * if we found a cert matching the magic_number of the
+ * query, NULL otherwise.
*/
-static const KeyPair *
-dnsc_find_keypair(struct dnsc_env* dnscenv, struct sldns_buffer* buffer)
+static const dnsccert *
+dnsc_find_cert(struct dnsc_env* dnscenv, struct sldns_buffer* buffer)
{
- const KeyPair *keypairs = dnscenv->keypairs;
+ const dnsccert *certs = dnscenv->certs;
struct dnscrypt_query_header *dnscrypt_header;
size_t i;
return NULL;
}
dnscrypt_header = (struct dnscrypt_query_header *)sldns_buffer_begin(buffer);
- for (i = 0U; i < dnscenv->keypairs_count; i++) {
- if (memcmp(keypairs[i].crypt_publickey, dnscrypt_header->magic_query,
+ for (i = 0U; i < dnscenv->signed_certs_count; i++) {
+ if (memcmp(certs[i].magic_query, dnscrypt_header->magic_query,
DNSCRYPT_MAGIC_HEADER_LEN) == 0) {
- return &keypairs[i];
+ return &certs[i];
}
}
return NULL;
return dnscenv->signed_certs_count;
}
+static const char *
+key_get_es_version(uint8_t version[2])
+{
+ struct es_version {
+ uint8_t es_version[2];
+ const char *name;
+ };
+
+ struct es_version es_versions[] = {
+ {{0x00, 0x01}, "X25519-XSalsa20Poly1305"},
+ {{0x00, 0x02}, "X25519-XChacha20Poly1305"},
+ };
+ int i;
+ for(i=0; i < (int)sizeof(es_versions); i++){
+ if(es_versions[i].es_version[0] == version[0] &&
+ es_versions[i].es_version[1] == version[1]){
+ return es_versions[i].name;
+ }
+ }
+ return NULL;
+}
+
+
/**
* Parse the secret key files from `dnscrypt-secret-key` config and populates
- * a list of secret/public keys supported by dnscrypt listener.
+ * a list of dnsccert with es_version, magic number and secret/public keys
+ * supported by dnscrypt listener.
* \param[in] env The dnsc_env structure which will hold the keypairs.
* \param[in] cfg The config with the secret key file paths.
*/
dnsc_parse_keys(struct dnsc_env *env, struct config_file *cfg)
{
struct config_strlist *head;
- size_t keypair_id;
+ size_t cert_id, keypair_id;
+ size_t c;
char *nm;
env->keypairs_count = 0U;
for (head = cfg->dnscrypt_secret_key; head; head = head->next) {
env->keypairs_count++;
}
+
env->keypairs = sodium_allocarray(env->keypairs_count,
- sizeof *env->keypairs);
+ sizeof *env->keypairs);
+ env->certs = sodium_allocarray(env->signed_certs_count,
+ sizeof *env->certs);
+ cert_id = 0U;
keypair_id = 0U;
for(head = cfg->dnscrypt_secret_key; head; head = head->next, keypair_id++) {
char fingerprint[80];
+ int found_cert = 0;
+ KeyPair *current_keypair = &env->keypairs[keypair_id];
nm = dnsc_chroot_path(cfg, head->str);
if(dnsc_read_from_file(
nm,
- (char *)(env->keypairs[keypair_id].crypt_secretkey),
+ (char *)(current_keypair->crypt_secretkey),
crypto_box_SECRETKEYBYTES) != 0) {
fatal_exit("dnsc_parse_keys: failed to load %s: %s", head->str, strerror(errno));
}
verbose(VERB_OPS, "Loaded key %s", head->str);
- if (crypto_scalarmult_base(env->keypairs[keypair_id].crypt_publickey,
- env->keypairs[keypair_id].crypt_secretkey) != 0) {
+ if (crypto_scalarmult_base(current_keypair->crypt_publickey,
+ current_keypair->crypt_secretkey) != 0) {
fatal_exit("dnsc_parse_keys: could not generate public key from %s", head->str);
}
- dnsc_key_to_fingerprint(fingerprint, env->keypairs[keypair_id].crypt_publickey);
+ dnsc_key_to_fingerprint(fingerprint, current_keypair->crypt_publickey);
verbose(VERB_OPS, "Crypt public key fingerprint for %s: %s", head->str, fingerprint);
+ // find the cert matching this key
+ for(c = 0; c < env->signed_certs_count; c++) {
+ if(memcmp(current_keypair->crypt_publickey,
+ env->signed_certs[c].server_publickey,
+ crypto_box_PUBLICKEYBYTES) == 0) {
+ dnsccert *current_cert = &env->certs[cert_id++];
+ found_cert = 1;
+ current_cert->keypair = current_keypair;
+ memcpy(current_cert->magic_query,
+ env->signed_certs[c].magic_query,
+ sizeof env->signed_certs[c].magic_query);
+ memcpy(current_cert->es_version,
+ env->signed_certs[c].version_major,
+ sizeof env->signed_certs[c].version_major
+ );
+ dnsc_key_to_fingerprint(fingerprint,
+ current_cert->keypair->crypt_publickey);
+ verbose(VERB_OPS, "Crypt public key fingerprint for %s: %s",
+ head->str, fingerprint);
+ verbose(VERB_OPS, "Using %s",
+ key_get_es_version(current_cert->es_version));
+#ifndef HAVE_XCHACHA20
+ if (current_cert->es_version[1] == 0x02) {
+ fatal_exit("Certificate for XChacha20 but libsodium does not support it.");
+ }
+#endif
+
+ }
+ }
+ if (!found_cert) {
+ fatal_exit("dnsc_parse_keys: could not match certificate for key "
+ "%s. Unable to determine ES version.",
+ head->str);
+ }
}
- return keypair_id;
+ return cert_id;
}
// Attempt to decrypt the query. If it is not crypted, we may still need
// to serve the certificate.
verbose(VERB_ALGO, "handle request called on DNSCrypt socket");
- if ((repinfo->keypair = dnsc_find_keypair(dnscenv, c->buffer)) != NULL) {
- if(dnscrypt_server_uncurve(repinfo->keypair,
+ if ((repinfo->dnsc_cert = dnsc_find_cert(dnscenv, c->buffer)) != NULL) {
+ if(dnscrypt_server_uncurve(repinfo->dnsc_cert,
repinfo->client_nonce,
repinfo->nmkey,
c->buffer) != 0){
if(!repinfo->is_dnscrypted) {
return 1;
}
- if(dnscrypt_server_curve(repinfo->keypair,
+ if(dnscrypt_server_curve(repinfo->dnsc_cert,
repinfo->client_nonce,
repinfo->nmkey,
repinfo->c->dnscrypt_buffer,
projects / thirdparty / unbound.git / commitdiff
