12947093256

Committed 24 Jan 2025 09:41AM UTC coverage: 61.737% (-3.0%) from 64.699%

Build # 12947093256

Build Type

Pull #15083

github

Committed by

web-flow

Commit Message

Merge 5ce14287c into 2800f06a9

Pull Request Pull Request #15083: Provide additional answers in NAPTR queries

Run Details

35896 of 90326 branches covered (39.74%)

Branch coverage included in aggregate %.

23 of 24 new or added lines in 1 file covered. (95.83%)

5202 existing lines in 75 files now uncovered.

122631 of 166451 relevant lines covered (73.67%)

3832131.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

25.18

/modules/bindbackend/binddnssec.cc

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "bindbackend2.hh"
#include "pdns/arguments.hh"
#include "pdns/dnsrecords.hh"

#ifndef HAVE_SQLITE3

void Bind2Backend::setupDNSSEC()
{
  if (!getArg("dnssec-db").empty()) {
    throw runtime_error("bind-dnssec-db requires building PowerDNS with SQLite3");
  }
}

bool Bind2Backend::doesDNSSEC()
{
  return d_hybrid;
}

bool Bind2Backend::getNSEC3PARAM(const DNSName& /* name */, NSEC3PARAMRecordContent* /* ns3p */)
{
  return false;
}

bool Bind2Backend::getNSEC3PARAMuncached(const DNSName& /* name */, NSEC3PARAMRecordContent* /* ns3p */)
{
  return false;
}

bool Bind2Backend::getAllDomainMetadata(const DNSName& /* name */, std::map<std::string, std::vector<std::string>>& /* meta */)
{
  return false;
}

bool Bind2Backend::getDomainMetadata(const DNSName& /* name */, const std::string& /* kind */, std::vector<std::string>& /* meta */)
{
  return false;
}

bool Bind2Backend::setDomainMetadata(const DNSName& /* name */, const std::string& /* kind */, const std::vector<std::string>& /* meta */)
{
  return false;
}

bool Bind2Backend::getDomainKeys(const DNSName& /* name */, std::vector<KeyData>& /* keys */)
{
  return false;
}

bool Bind2Backend::removeDomainKey(const DNSName& /* name */, unsigned int /* id */)
{
  return false;
}

bool Bind2Backend::addDomainKey(const DNSName& /* name */, const KeyData& /* key */, int64_t& /* id */)
{
  return false;
}

bool Bind2Backend::activateDomainKey(const DNSName& /* name */, unsigned int /* id */)
{
  return false;
}

bool Bind2Backend::deactivateDomainKey(const DNSName& /* name */, unsigned int /* id */)
{
  return false;
}

bool Bind2Backend::publishDomainKey(const DNSName& /* name */, unsigned int /* id */)
{
  return false;
}

bool Bind2Backend::unpublishDomainKey(const DNSName& /* name */, unsigned int /* id */)
{
  return false;
}

bool Bind2Backend::getTSIGKey(const DNSName& /* name */, DNSName& /* algorithm */, string& /* content */)
{
  return false;
}

bool Bind2Backend::setTSIGKey(const DNSName& /* name */, const DNSName& /* algorithm */, const string& /* content */)
{
  return false;
}

bool Bind2Backend::deleteTSIGKey(const DNSName& /* name */)
{
  return false;
}

bool Bind2Backend::getTSIGKeys(std::vector<struct TSIGKey>& /* keys */)
{
  return false;
}

void Bind2Backend::setupStatements()
{
}

void Bind2Backend::freeStatements()
{
}

#else

#include "pdns/logger.hh"
#include "pdns/ssqlite3.hh"

#define ASSERT_ROW_COLUMNS(query, row, num)                                                                                                \
  {                                                                                                                                        \
    if (row.size() != num) {                                                                                                               \
      throw PDNSException(std::string(query) + " returned wrong number of columns, expected " #num ", got " + std::to_string(row.size())); \
    }                                                                                                                                      \
  }

void Bind2Backend::setupDNSSEC()
{
  if (getArg("dnssec-db").empty() || d_hybrid)
    return;
  try {
    d_dnssecdb = std::make_shared<SSQLite3>(getArg("dnssec-db"), getArg("dnssec-db-journal-mode"));
    setupStatements();
  }
  catch (SSqlException& se) {
    // this error is meant to kill the server dead - it makes no sense to continue..
    throw runtime_error("Error opening DNSSEC database in BIND backend: " + se.txtReason());
  }

  d_dnssecdb->setLog(::arg().mustDo("query-logging"));
}

void Bind2Backend::setupStatements()
{
  d_getAllDomainMetadataQuery_stmt = d_dnssecdb->prepare("select kind, content from domainmetadata where domain=:domain", 1);
  d_getDomainMetadataQuery_stmt = d_dnssecdb->prepare("select content from domainmetadata where domain=:domain and kind=:kind", 2);
  d_deleteDomainMetadataQuery_stmt = d_dnssecdb->prepare("delete from domainmetadata where domain=:domain and kind=:kind", 2);
  d_insertDomainMetadataQuery_stmt = d_dnssecdb->prepare("insert into domainmetadata (domain, kind, content) values (:domain,:kind,:content)", 3);
  d_getDomainKeysQuery_stmt = d_dnssecdb->prepare("select id,flags, active, published, content from cryptokeys where domain=:domain", 1);
  d_deleteDomainKeyQuery_stmt = d_dnssecdb->prepare("delete from cryptokeys where domain=:domain and id=:key_id", 2);
  d_insertDomainKeyQuery_stmt = d_dnssecdb->prepare("insert into cryptokeys (domain, flags, active, published, content) values (:domain, :flags, :active, :published, :content)", 5);
  d_GetLastInsertedKeyIdQuery_stmt = d_dnssecdb->prepare("select last_insert_rowid()", 0);
  d_activateDomainKeyQuery_stmt = d_dnssecdb->prepare("update cryptokeys set active=1 where domain=:domain and id=:key_id", 2);
  d_deactivateDomainKeyQuery_stmt = d_dnssecdb->prepare("update cryptokeys set active=0 where domain=:domain and id=:key_id", 2);
  d_publishDomainKeyQuery_stmt = d_dnssecdb->prepare("update cryptokeys set published=1 where domain=:domain and id=:key_id", 2);
  d_unpublishDomainKeyQuery_stmt = d_dnssecdb->prepare("update cryptokeys set published=0 where domain=:domain and id=:key_id", 2);
  d_getTSIGKeyQuery_stmt = d_dnssecdb->prepare("select algorithm, secret from tsigkeys where name=:key_name", 1);
  d_setTSIGKeyQuery_stmt = d_dnssecdb->prepare("replace into tsigkeys (name,algorithm,secret) values(:key_name, :algorithm, :content)", 3);
  d_deleteTSIGKeyQuery_stmt = d_dnssecdb->prepare("delete from tsigkeys where name=:key_name", 1);
  d_getTSIGKeysQuery_stmt = d_dnssecdb->prepare("select name,algorithm,secret from tsigkeys", 0);
}

void Bind2Backend::freeStatements()
{
  d_getAllDomainMetadataQuery_stmt.reset();
  d_getDomainMetadataQuery_stmt.reset();
  d_deleteDomainMetadataQuery_stmt.reset();
  d_insertDomainMetadataQuery_stmt.reset();
  d_getDomainKeysQuery_stmt.reset();
  d_deleteDomainKeyQuery_stmt.reset();
  d_insertDomainKeyQuery_stmt.reset();
  d_GetLastInsertedKeyIdQuery_stmt.reset();
  d_activateDomainKeyQuery_stmt.reset();
  d_deactivateDomainKeyQuery_stmt.reset();
  d_publishDomainKeyQuery_stmt.reset();
  d_unpublishDomainKeyQuery_stmt.reset();
  d_getTSIGKeyQuery_stmt.reset();
  d_setTSIGKeyQuery_stmt.reset();
  d_deleteTSIGKeyQuery_stmt.reset();
  d_getTSIGKeysQuery_stmt.reset();
}

bool Bind2Backend::doesDNSSEC()
{
  return d_dnssecdb || d_hybrid;
}

bool Bind2Backend::getNSEC3PARAM(const DNSName& name, NSEC3PARAMRecordContent* ns3p)
{
  BB2DomainInfo bbd;
  if (!safeGetBBDomainInfo(name, &bbd))
    return false;

  if (ns3p != nullptr) {
    *ns3p = bbd.d_nsec3param;
  }

  return bbd.d_nsec3zone;
}

bool Bind2Backend::getNSEC3PARAMuncached(const DNSName& name, NSEC3PARAMRecordContent* ns3p)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  string value;
  vector<string> meta;
  getDomainMetadata(name, "NSEC3PARAM", meta);
  if (!meta.empty())
    value = *meta.begin();
  else
    return false; // No NSEC3 zone

  static int maxNSEC3Iterations = ::arg().asNum("max-nsec3-iterations");
  if (ns3p) {
    auto tmp = std::dynamic_pointer_cast<NSEC3PARAMRecordContent>(DNSRecordContent::make(QType::NSEC3PARAM, 1, value));
    *ns3p = *tmp;

    if (ns3p->d_iterations > maxNSEC3Iterations) {
      ns3p->d_iterations = maxNSEC3Iterations;
      g_log << Logger::Error << "Number of NSEC3 iterations for zone '" << name << "' is above 'max-nsec3-iterations'. Value adjusted to: " << maxNSEC3Iterations << endl;
    }

    if (ns3p->d_algorithm != 1) {
      g_log << Logger::Error << "Invalid hash algorithm for NSEC3: '" << std::to_string(ns3p->d_algorithm) << "', setting to 1 for zone '" << name << "'." << endl;
      ns3p->d_algorithm = 1;
    }
  }

  return true;
}

bool Bind2Backend::getAllDomainMetadata(const DNSName& name, std::map<std::string, std::vector<std::string>>& meta)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_getAllDomainMetadataQuery_stmt->bind("domain", name)->execute();

    SSqlStatement::row_t row;
    while (d_getAllDomainMetadataQuery_stmt->hasNextRow()) {
      d_getAllDomainMetadataQuery_stmt->nextRow(row);
      meta[row[0]].push_back(row[1]);
    }

    d_getAllDomainMetadataQuery_stmt->reset();
  }
  catch (SSqlException& se) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, getAllDomainMetadata(): " + se.txtReason());
  }
  return true;
}

bool Bind2Backend::getDomainMetadata(const DNSName& name, const std::string& kind, std::vector<std::string>& meta)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_getDomainMetadataQuery_stmt->bind("domain", name)->bind("kind", kind)->execute();

    SSqlStatement::row_t row;
    while (d_getDomainMetadataQuery_stmt->hasNextRow()) {
      d_getDomainMetadataQuery_stmt->nextRow(row);
      meta.push_back(row[0]);
    }

    d_getDomainMetadataQuery_stmt->reset();
  }
  catch (SSqlException& se) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, getDomainMetadata(): " + se.txtReason());
  }
  return true;
}

bool Bind2Backend::setDomainMetadata(const DNSName& name, const std::string& kind, const std::vector<std::string>& meta)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_deleteDomainMetadataQuery_stmt->bind("domain", name)->bind("kind", kind)->execute()->reset();
    if (!meta.empty()) {
      for (const auto& value : meta) {
        d_insertDomainMetadataQuery_stmt->bind("domain", name)->bind("kind", kind)->bind("content", value)->execute()->reset();
      }
    }
  }
  catch (SSqlException& se) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, setDomainMetadata(): " + se.txtReason());
  }
  return true;
}

bool Bind2Backend::getDomainKeys(const DNSName& name, std::vector<KeyData>& keys)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_getDomainKeysQuery_stmt->bind("domain", name)->execute();

    KeyData kd;
    SSqlStatement::row_t row;
    while (d_getDomainKeysQuery_stmt->hasNextRow()) {
      d_getDomainKeysQuery_stmt->nextRow(row);
      pdns::checked_stoi_into(kd.id, row[0]);
      pdns::checked_stoi_into(kd.flags, row[1]);
      kd.active = (row[2] == "1");
      kd.published = (row[3] == "1");
      kd.content = row[4];
      keys.push_back(kd);
    }

    d_getDomainKeysQuery_stmt->reset();
  }
  catch (SSqlException& se) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, getDomainKeys(): " + se.txtReason());
  }
  return true;
}

bool Bind2Backend::removeDomainKey(const DNSName& name, unsigned int id)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_deleteDomainKeyQuery_stmt->bind("domain", name)->bind("key_id", id)->execute()->reset();
  }
  catch (SSqlException& se) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, removeDomainKeys(): " + se.txtReason());
  }
  return true;
}

bool Bind2Backend::addDomainKey(const DNSName& name, const KeyData& key, int64_t& id)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_insertDomainKeyQuery_stmt->bind("domain", name)->bind("flags", key.flags)->bind("active", key.active)->bind("published", key.published)->bind("content", key.content)->execute()->reset();
  }
  catch (SSqlException& se) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, addDomainKey(): " + se.txtReason());
  }

  try {
    d_GetLastInsertedKeyIdQuery_stmt->execute();
    if (!d_GetLastInsertedKeyIdQuery_stmt->hasNextRow()) {
      id = -2;
      return true;
    }
    SSqlStatement::row_t row;
    d_GetLastInsertedKeyIdQuery_stmt->nextRow(row);
    ASSERT_ROW_COLUMNS("get-last-inserted-key-id-query", row, 1);
    id = std::stoi(row[0]);
    d_GetLastInsertedKeyIdQuery_stmt->reset();
    if (id == 0) {
      // No insert took place, report as error.
      id = -1;
    }
    return true;
  }
  catch (SSqlException& e) {
    id = -2;
    return true;
  }
}

bool Bind2Backend::activateDomainKey(const DNSName& name, unsigned int id)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_activateDomainKeyQuery_stmt->bind("domain", name)->bind("key_id", id)->execute()->reset();
  }
  catch (SSqlException& se) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, activateDomainKey(): " + se.txtReason());
  }
  return true;
}

bool Bind2Backend::deactivateDomainKey(const DNSName& name, unsigned int id)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_deactivateDomainKeyQuery_stmt->bind("domain", name)->bind("key_id", id)->execute()->reset();
  }
  catch (SSqlException& se) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, deactivateDomainKey(): " + se.txtReason());
  }
  return true;
}

bool Bind2Backend::publishDomainKey(const DNSName& name, unsigned int id)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_publishDomainKeyQuery_stmt->bind("domain", name)->bind("key_id", id)->execute()->reset();
  }
  catch (SSqlException& se) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, publishDomainKey(): " + se.txtReason());
  }
  return true;
}

bool Bind2Backend::unpublishDomainKey(const DNSName& name, unsigned int id)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_unpublishDomainKeyQuery_stmt->bind("domain", name)->bind("key_id", id)->execute()->reset();
  }
  catch (SSqlException& se) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, unpublishDomainKey(): " + se.txtReason());
  }
  return true;
}

bool Bind2Backend::getTSIGKey(const DNSName& name, DNSName& algorithm, string& content)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_getTSIGKeyQuery_stmt->bind("key_name", name)->execute();

    SSqlStatement::row_t row;
    while (d_getTSIGKeyQuery_stmt->hasNextRow()) {
      d_getTSIGKeyQuery_stmt->nextRow(row);
      if (row.size() >= 2 && (algorithm.empty() || algorithm == DNSName(row[0]))) {
        algorithm = DNSName(row[0]);
        content = row[1];
      }
    }

    d_getTSIGKeyQuery_stmt->reset();
  }
  catch (SSqlException& e) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, getTSIGKey(): " + e.txtReason());
  }
  return true;
}

bool Bind2Backend::setTSIGKey(const DNSName& name, const DNSName& algorithm, const string& content)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_setTSIGKeyQuery_stmt->bind("key_name", name)->bind("algorithm", algorithm)->bind("content", content)->execute()->reset();
  }
  catch (SSqlException& e) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, setTSIGKey(): " + e.txtReason());
  }
  return true;
}

bool Bind2Backend::deleteTSIGKey(const DNSName& name)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_deleteTSIGKeyQuery_stmt->bind("key_name", name)->execute()->reset();
  }
  catch (SSqlException& e) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, deleteTSIGKey(): " + e.txtReason());
  }
  return true;
}

bool Bind2Backend::getTSIGKeys(std::vector<struct TSIGKey>& keys)
{
  if (!d_dnssecdb || d_hybrid)
    return false;

  try {
    d_getTSIGKeysQuery_stmt->execute();

    SSqlStatement::row_t row;
    while (d_getTSIGKeysQuery_stmt->hasNextRow()) {
      d_getTSIGKeysQuery_stmt->nextRow(row);
      struct TSIGKey key;
      key.name = DNSName(row[0]);
      key.algorithm = DNSName(row[1]);
      key.key = row[2];
      keys.push_back(key);
    }

    d_getTSIGKeysQuery_stmt->reset();
  }
  catch (SSqlException& e) {
    throw PDNSException("Error accessing DNSSEC database in BIND backend, getTSIGKeys(): " + e.txtReason());
  }
  return true;
}

#endif

1	/*
2	* This file is part of PowerDNS or dnsdist.
3	* Copyright -- PowerDNS.COM B.V. and its contributors
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of version 2 of the GNU General Public License as
7	* published by the Free Software Foundation.
8	*
9	* In addition, for the avoidance of any doubt, permission is granted to
10	* link this program with OpenSSL and to (re)distribute the binaries
11	* produced as the result of such linking.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21	*/
22
23	#ifdef HAVE_CONFIG_H
24	#include "config.h"
25	#endif
26	#include "bindbackend2.hh"
27	#include "pdns/arguments.hh"
28	#include "pdns/dnsrecords.hh"
29
30	#ifndef HAVE_SQLITE3
31
32	void Bind2Backend::setupDNSSEC()
33	{
34	if (!getArg("dnssec-db").empty()) {
35	throw runtime_error("bind-dnssec-db requires building PowerDNS with SQLite3");
36	}
37	}
38
39	bool Bind2Backend::doesDNSSEC()
40	{
41	return d_hybrid;
42	}
43
44	bool Bind2Backend::getNSEC3PARAM(const DNSName& /* name /, NSEC3PARAMRecordContent /* ns3p */)
45	{
46	return false;
47	}
48
49	bool Bind2Backend::getNSEC3PARAMuncached(const DNSName& /* name /, NSEC3PARAMRecordContent /* ns3p */)
50	{
51	return false;
52	}
53
54	bool Bind2Backend::getAllDomainMetadata(const DNSName& /* name /, std::map<std::string, std::vector<std::string>>& / meta */)
55	{
56	return false;
57	}
58
59	bool Bind2Backend::getDomainMetadata(const DNSName& /* name /, const std::string& / kind /, std::vector<std::string>& / meta */)
60	{
61	return false;
62	}
63
64	bool Bind2Backend::setDomainMetadata(const DNSName& /* name /, const std::string& / kind /, const std::vector<std::string>& / meta */)
65	{
66	return false;
67	}
68
69	bool Bind2Backend::getDomainKeys(const DNSName& /* name /, std::vector<KeyData>& / keys */)
70	{
71	return false;
72	}
73
74	bool Bind2Backend::removeDomainKey(const DNSName& /* name /, unsigned int / id */)
75	{
76	return false;
77	}
78
79	bool Bind2Backend::addDomainKey(const DNSName& /* name /, const KeyData& / key /, int64_t& / id */)
80	{
81	return false;
82	}
83
84	bool Bind2Backend::activateDomainKey(const DNSName& /* name /, unsigned int / id */)
85	{
86	return false;
87	}
88
89	bool Bind2Backend::deactivateDomainKey(const DNSName& /* name /, unsigned int / id */)
90	{
91	return false;
92	}
93
94	bool Bind2Backend::publishDomainKey(const DNSName& /* name /, unsigned int / id */)
95	{
96	return false;
97	}
98
99	bool Bind2Backend::unpublishDomainKey(const DNSName& /* name /, unsigned int / id */)
100	{
101	return false;
102	}
103
104	bool Bind2Backend::getTSIGKey(const DNSName& /* name /, DNSName& / algorithm /, string& / content */)
105	{
106	return false;
107	}
108
109	bool Bind2Backend::setTSIGKey(const DNSName& /* name /, const DNSName& / algorithm /, const string& / content */)
110	{
111	return false;
112	}
113
114	bool Bind2Backend::deleteTSIGKey(const DNSName& /* name */)
115	{
116	return false;
117	}
118
119	bool Bind2Backend::getTSIGKeys(std::vector<struct TSIGKey>& /* keys */)
120	{
121	return false;
122	}
123
124	void Bind2Backend::setupStatements()
125	{
126	}
127
128	void Bind2Backend::freeStatements()
129	{
130	}
131
132	#else
133
134	#include "pdns/logger.hh"
135	#include "pdns/ssqlite3.hh"
136
137	#define ASSERT_ROW_COLUMNS(query, row, num) \
138	{ \	15✔
139	if (row.size() != num) { \	15✔
140	throw PDNSException(std::string(query) + " returned wrong number of columns, expected " #num ", got " + std::to_string(row.size())); \	×
141	} \	×
142	}	15✔
143
144	void Bind2Backend::setupDNSSEC()
145	{	1,773✔
146	if (getArg("dnssec-db").empty() \|\| d_hybrid)	1,773!
147	return;	1,752✔
148	try {	21✔
149	d_dnssecdb = std::make_shared<SSQLite3>(getArg("dnssec-db"), getArg("dnssec-db-journal-mode"));	21✔
150	setupStatements();	21✔
151	}	21✔
152	catch (SSqlException& se) {	21✔
153	// this error is meant to kill the server dead - it makes no sense to continue..
154	throw runtime_error("Error opening DNSSEC database in BIND backend: " + se.txtReason());	×
155	}	×
156
157	d_dnssecdb->setLog(::arg().mustDo("query-logging"));	21✔
158	}	21✔
159
160	void Bind2Backend::setupStatements()
161	{	21✔
162	d_getAllDomainMetadataQuery_stmt = d_dnssecdb->prepare("select kind, content from domainmetadata where domain=:domain", 1);	21✔
163	d_getDomainMetadataQuery_stmt = d_dnssecdb->prepare("select content from domainmetadata where domain=:domain and kind=:kind", 2);	21✔
164	d_deleteDomainMetadataQuery_stmt = d_dnssecdb->prepare("delete from domainmetadata where domain=:domain and kind=:kind", 2);	21✔
165	d_insertDomainMetadataQuery_stmt = d_dnssecdb->prepare("insert into domainmetadata (domain, kind, content) values (:domain,:kind,:content)", 3);	21✔
166	d_getDomainKeysQuery_stmt = d_dnssecdb->prepare("select id,flags, active, published, content from cryptokeys where domain=:domain", 1);	21✔
167	d_deleteDomainKeyQuery_stmt = d_dnssecdb->prepare("delete from cryptokeys where domain=:domain and id=:key_id", 2);	21✔
168	d_insertDomainKeyQuery_stmt = d_dnssecdb->prepare("insert into cryptokeys (domain, flags, active, published, content) values (:domain, :flags, :active, :published, :content)", 5);	21✔
169	d_GetLastInsertedKeyIdQuery_stmt = d_dnssecdb->prepare("select last_insert_rowid()", 0);	21✔
170	d_activateDomainKeyQuery_stmt = d_dnssecdb->prepare("update cryptokeys set active=1 where domain=:domain and id=:key_id", 2);	21✔
171	d_deactivateDomainKeyQuery_stmt = d_dnssecdb->prepare("update cryptokeys set active=0 where domain=:domain and id=:key_id", 2);	21✔
172	d_publishDomainKeyQuery_stmt = d_dnssecdb->prepare("update cryptokeys set published=1 where domain=:domain and id=:key_id", 2);	21✔
173	d_unpublishDomainKeyQuery_stmt = d_dnssecdb->prepare("update cryptokeys set published=0 where domain=:domain and id=:key_id", 2);	21✔
174	d_getTSIGKeyQuery_stmt = d_dnssecdb->prepare("select algorithm, secret from tsigkeys where name=:key_name", 1);	21✔
175	d_setTSIGKeyQuery_stmt = d_dnssecdb->prepare("replace into tsigkeys (name,algorithm,secret) values(:key_name, :algorithm, :content)", 3);	21✔
176	d_deleteTSIGKeyQuery_stmt = d_dnssecdb->prepare("delete from tsigkeys where name=:key_name", 1);	21✔
177	d_getTSIGKeysQuery_stmt = d_dnssecdb->prepare("select name,algorithm,secret from tsigkeys", 0);	21✔
178	}	21✔
179
180	void Bind2Backend::freeStatements()
181	{	1,757✔
182	d_getAllDomainMetadataQuery_stmt.reset();	1,757✔
183	d_getDomainMetadataQuery_stmt.reset();	1,757✔
184	d_deleteDomainMetadataQuery_stmt.reset();	1,757✔
185	d_insertDomainMetadataQuery_stmt.reset();	1,757✔
186	d_getDomainKeysQuery_stmt.reset();	1,757✔
187	d_deleteDomainKeyQuery_stmt.reset();	1,757✔
188	d_insertDomainKeyQuery_stmt.reset();	1,757✔
189	d_GetLastInsertedKeyIdQuery_stmt.reset();	1,757✔
190	d_activateDomainKeyQuery_stmt.reset();	1,757✔
191	d_deactivateDomainKeyQuery_stmt.reset();	1,757✔
192	d_publishDomainKeyQuery_stmt.reset();	1,757✔
193	d_unpublishDomainKeyQuery_stmt.reset();	1,757✔
194	d_getTSIGKeyQuery_stmt.reset();	1,757✔
195	d_setTSIGKeyQuery_stmt.reset();	1,757✔
196	d_deleteTSIGKeyQuery_stmt.reset();	1,757✔
197	d_getTSIGKeysQuery_stmt.reset();	1,757✔
198	}	1,757✔
199
200	bool Bind2Backend::doesDNSSEC()
UNCOV 201	{	×
UNCOV 202	return d_dnssecdb \|\| d_hybrid;	×
UNCOV 203	}	×
204
205	bool Bind2Backend::getNSEC3PARAM(const DNSName& name, NSEC3PARAMRecordContent* ns3p)
206	{	×
207	BB2DomainInfo bbd;	×
208	if (!safeGetBBDomainInfo(name, &bbd))	×
209	return false;	×
210
211	if (ns3p != nullptr) {	×
212	*ns3p = bbd.d_nsec3param;	×
213	}	×
214
215	return bbd.d_nsec3zone;	×
216	}	×
217
218	bool Bind2Backend::getNSEC3PARAMuncached(const DNSName& name, NSEC3PARAMRecordContent* ns3p)
219	{	2✔
220	if (!d_dnssecdb \|\| d_hybrid)	2!
UNCOV 221	return false;	×
222
223	string value;	2✔
224	vector<string> meta;	2✔
225	getDomainMetadata(name, "NSEC3PARAM", meta);	2✔
226	if (!meta.empty())	2!
UNCOV 227	value = *meta.begin();	×
228	else	2✔
229	return false; // No NSEC3 zone	2✔
230
UNCOV 231	static int maxNSEC3Iterations = ::arg().asNum("max-nsec3-iterations");	×
UNCOV 232	if (ns3p) {	×
UNCOV 233	auto tmp = std::dynamic_pointer_cast<NSEC3PARAMRecordContent>(DNSRecordContent::make(QType::NSEC3PARAM, 1, value));	×
UNCOV 234	ns3p = tmp;	×
235
UNCOV 236	if (ns3p->d_iterations > maxNSEC3Iterations) {	×
237	ns3p->d_iterations = maxNSEC3Iterations;	×
238	g_log << Logger::Error << "Number of NSEC3 iterations for zone '" << name << "' is above 'max-nsec3-iterations'. Value adjusted to: " << maxNSEC3Iterations << endl;	×
239	}	×
240
UNCOV 241	if (ns3p->d_algorithm != 1) {	×
242	g_log << Logger::Error << "Invalid hash algorithm for NSEC3: '" << std::to_string(ns3p->d_algorithm) << "', setting to 1 for zone '" << name << "'." << endl;	×
243	ns3p->d_algorithm = 1;	×
244	}	×
UNCOV 245	}	×
246
UNCOV 247	return true;	×
248	}	2✔
249
250	bool Bind2Backend::getAllDomainMetadata(const DNSName& name, std::map<std::string, std::vector<std::string>>& meta)
UNCOV 251	{	×
UNCOV 252	if (!d_dnssecdb \|\| d_hybrid)	×
UNCOV 253	return false;	×
254
UNCOV 255	try {	×
UNCOV 256	d_getAllDomainMetadataQuery_stmt->bind("domain", name)->execute();	×
257
UNCOV 258	SSqlStatement::row_t row;	×
UNCOV 259	while (d_getAllDomainMetadataQuery_stmt->hasNextRow()) {	×
UNCOV 260	d_getAllDomainMetadataQuery_stmt->nextRow(row);	×
UNCOV 261	meta[row[0]].push_back(row[1]);	×
UNCOV 262	}	×
263
UNCOV 264	d_getAllDomainMetadataQuery_stmt->reset();	×
UNCOV 265	}	×
UNCOV 266	catch (SSqlException& se) {	×
267	throw PDNSException("Error accessing DNSSEC database in BIND backend, getAllDomainMetadata(): " + se.txtReason());	×
268	}	×
UNCOV 269	return true;	×
UNCOV 270	}	×
271
272	bool Bind2Backend::getDomainMetadata(const DNSName& name, const std::string& kind, std::vector<std::string>& meta)
273	{	6✔
274	if (!d_dnssecdb \|\| d_hybrid)	6!
275	return false;	4✔
276
277	try {	2✔
278	d_getDomainMetadataQuery_stmt->bind("domain", name)->bind("kind", kind)->execute();	2✔
279
280	SSqlStatement::row_t row;	2✔
281	while (d_getDomainMetadataQuery_stmt->hasNextRow()) {	2!
UNCOV 282	d_getDomainMetadataQuery_stmt->nextRow(row);	×
UNCOV 283	meta.push_back(row[0]);	×
UNCOV 284	}	×
285
286	d_getDomainMetadataQuery_stmt->reset();	2✔
287	}	2✔
288	catch (SSqlException& se) {	2✔
289	throw PDNSException("Error accessing DNSSEC database in BIND backend, getDomainMetadata(): " + se.txtReason());	×
290	}	×
291	return true;	2✔
292	}	2✔
293
294	bool Bind2Backend::setDomainMetadata(const DNSName& name, const std::string& kind, const std::vector<std::string>& meta)
UNCOV 295	{	×
UNCOV 296	if (!d_dnssecdb \|\| d_hybrid)	×
297	return false;	×
298
UNCOV 299	try {	×
UNCOV 300	d_deleteDomainMetadataQuery_stmt->bind("domain", name)->bind("kind", kind)->execute()->reset();	×
UNCOV 301	if (!meta.empty()) {	×
UNCOV 302	for (const auto& value : meta) {	×
UNCOV 303	d_insertDomainMetadataQuery_stmt->bind("domain", name)->bind("kind", kind)->bind("content", value)->execute()->reset();	×
UNCOV 304	}	×
UNCOV 305	}	×
UNCOV 306	}	×
UNCOV 307	catch (SSqlException& se) {	×
308	throw PDNSException("Error accessing DNSSEC database in BIND backend, setDomainMetadata(): " + se.txtReason());	×
309	}	×
UNCOV 310	return true;	×
UNCOV 311	}	×
312
313	bool Bind2Backend::getDomainKeys(const DNSName& name, std::vector<KeyData>& keys)
UNCOV 314	{	×
UNCOV 315	if (!d_dnssecdb \|\| d_hybrid)	×
UNCOV 316	return false;	×
317
UNCOV 318	try {	×
UNCOV 319	d_getDomainKeysQuery_stmt->bind("domain", name)->execute();	×
320
UNCOV 321	KeyData kd;	×
UNCOV 322	SSqlStatement::row_t row;	×
UNCOV 323	while (d_getDomainKeysQuery_stmt->hasNextRow()) {	×
UNCOV 324	d_getDomainKeysQuery_stmt->nextRow(row);	×
UNCOV 325	pdns::checked_stoi_into(kd.id, row[0]);	×
UNCOV 326	pdns::checked_stoi_into(kd.flags, row[1]);	×
UNCOV 327	kd.active = (row[2] == "1");	×
UNCOV 328	kd.published = (row[3] == "1");	×
UNCOV 329	kd.content = row[4];	×
UNCOV 330	keys.push_back(kd);	×
UNCOV 331	}	×
332
UNCOV 333	d_getDomainKeysQuery_stmt->reset();	×
UNCOV 334	}	×
UNCOV 335	catch (SSqlException& se) {	×
336	throw PDNSException("Error accessing DNSSEC database in BIND backend, getDomainKeys(): " + se.txtReason());	×
337	}	×
UNCOV 338	return true;	×
UNCOV 339	}	×
340
341	bool Bind2Backend::removeDomainKey(const DNSName& name, unsigned int id)
342	{	×
343	if (!d_dnssecdb \|\| d_hybrid)	×
344	return false;	×
345
346	try {	×
347	d_deleteDomainKeyQuery_stmt->bind("domain", name)->bind("key_id", id)->execute()->reset();	×
348	}	×
349	catch (SSqlException& se) {	×
350	throw PDNSException("Error accessing DNSSEC database in BIND backend, removeDomainKeys(): " + se.txtReason());	×
351	}	×
352	return true;	×
353	}	×
354
355	bool Bind2Backend::addDomainKey(const DNSName& name, const KeyData& key, int64_t& id)
356	{	15✔
357	if (!d_dnssecdb \|\| d_hybrid)	15!
358	return false;	×
359
360	try {	15✔
361	d_insertDomainKeyQuery_stmt->bind("domain", name)->bind("flags", key.flags)->bind("active", key.active)->bind("published", key.published)->bind("content", key.content)->execute()->reset();	15✔
362	}	15✔
363	catch (SSqlException& se) {	15✔
364	throw PDNSException("Error accessing DNSSEC database in BIND backend, addDomainKey(): " + se.txtReason());	×
365	}	×
366
367	try {	15✔
368	d_GetLastInsertedKeyIdQuery_stmt->execute();	15✔
369	if (!d_GetLastInsertedKeyIdQuery_stmt->hasNextRow()) {	15!
370	id = -2;	×
371	return true;	×
372	}	×
373	SSqlStatement::row_t row;	15✔
374	d_GetLastInsertedKeyIdQuery_stmt->nextRow(row);	15✔
375	ASSERT_ROW_COLUMNS("get-last-inserted-key-id-query", row, 1);	15!
376	id = std::stoi(row[0]);	15✔
377	d_GetLastInsertedKeyIdQuery_stmt->reset();	15✔
378	if (id == 0) {	15!
379	// No insert took place, report as error.
380	id = -1;	×
381	}	×
382	return true;	15✔
383	}	15✔
384	catch (SSqlException& e) {	15✔
385	id = -2;	×
386	return true;	×
387	}	×
388	}	15✔
389
390	bool Bind2Backend::activateDomainKey(const DNSName& name, unsigned int id)
391	{	×
392	if (!d_dnssecdb \|\| d_hybrid)	×
393	return false;	×
394
395	try {	×
396	d_activateDomainKeyQuery_stmt->bind("domain", name)->bind("key_id", id)->execute()->reset();	×
397	}	×
398	catch (SSqlException& se) {	×
399	throw PDNSException("Error accessing DNSSEC database in BIND backend, activateDomainKey(): " + se.txtReason());	×
400	}	×
401	return true;	×
402	}	×
403
404	bool Bind2Backend::deactivateDomainKey(const DNSName& name, unsigned int id)
405	{	×
406	if (!d_dnssecdb \|\| d_hybrid)	×
407	return false;	×
408
409	try {	×
410	d_deactivateDomainKeyQuery_stmt->bind("domain", name)->bind("key_id", id)->execute()->reset();	×
411	}	×
412	catch (SSqlException& se) {	×
413	throw PDNSException("Error accessing DNSSEC database in BIND backend, deactivateDomainKey(): " + se.txtReason());	×
414	}	×
415	return true;	×
416	}	×
417
418	bool Bind2Backend::publishDomainKey(const DNSName& name, unsigned int id)
419	{	×
420	if (!d_dnssecdb \|\| d_hybrid)	×
421	return false;	×
422
423	try {	×
424	d_publishDomainKeyQuery_stmt->bind("domain", name)->bind("key_id", id)->execute()->reset();	×
425	}	×
426	catch (SSqlException& se) {	×
427	throw PDNSException("Error accessing DNSSEC database in BIND backend, publishDomainKey(): " + se.txtReason());	×
428	}	×
429	return true;	×
430	}	×
431
432	bool Bind2Backend::unpublishDomainKey(const DNSName& name, unsigned int id)
UNCOV 433	{	×
UNCOV 434	if (!d_dnssecdb \|\| d_hybrid)	×
435	return false;	×
436
UNCOV 437	try {	×
UNCOV 438	d_unpublishDomainKeyQuery_stmt->bind("domain", name)->bind("key_id", id)->execute()->reset();	×
UNCOV 439	}	×
UNCOV 440	catch (SSqlException& se) {	×
441	throw PDNSException("Error accessing DNSSEC database in BIND backend, unpublishDomainKey(): " + se.txtReason());	×
442	}	×
UNCOV 443	return true;	×
UNCOV 444	}	×
445
446	bool Bind2Backend::getTSIGKey(const DNSName& name, DNSName& algorithm, string& content)
UNCOV 447	{	×
UNCOV 448	if (!d_dnssecdb \|\| d_hybrid)	×
449	return false;	×
450
UNCOV 451	try {	×
UNCOV 452	d_getTSIGKeyQuery_stmt->bind("key_name", name)->execute();	×
453
UNCOV 454	SSqlStatement::row_t row;	×
UNCOV 455	while (d_getTSIGKeyQuery_stmt->hasNextRow()) {	×
UNCOV 456	d_getTSIGKeyQuery_stmt->nextRow(row);	×
UNCOV 457	if (row.size() >= 2 && (algorithm.empty() \|\| algorithm == DNSName(row[0]))) {	×
UNCOV 458	algorithm = DNSName(row[0]);	×
UNCOV 459	content = row[1];	×
UNCOV 460	}	×
UNCOV 461	}	×
462
UNCOV 463	d_getTSIGKeyQuery_stmt->reset();	×
UNCOV 464	}	×
UNCOV 465	catch (SSqlException& e) {	×
466	throw PDNSException("Error accessing DNSSEC database in BIND backend, getTSIGKey(): " + e.txtReason());	×
467	}	×
UNCOV 468	return true;	×
UNCOV 469	}	×
470
471	bool Bind2Backend::setTSIGKey(const DNSName& name, const DNSName& algorithm, const string& content)
UNCOV 472	{	×
UNCOV 473	if (!d_dnssecdb \|\| d_hybrid)	×
474	return false;	×
475
UNCOV 476	try {	×
UNCOV 477	d_setTSIGKeyQuery_stmt->bind("key_name", name)->bind("algorithm", algorithm)->bind("content", content)->execute()->reset();	×
UNCOV 478	}	×
UNCOV 479	catch (SSqlException& e) {	×
480	throw PDNSException("Error accessing DNSSEC database in BIND backend, setTSIGKey(): " + e.txtReason());	×
481	}	×
UNCOV 482	return true;	×
UNCOV 483	}	×
484
485	bool Bind2Backend::deleteTSIGKey(const DNSName& name)
486	{	×
487	if (!d_dnssecdb \|\| d_hybrid)	×
488	return false;	×
489
490	try {	×
491	d_deleteTSIGKeyQuery_stmt->bind("key_name", name)->execute()->reset();	×
492	}	×
493	catch (SSqlException& e) {	×
494	throw PDNSException("Error accessing DNSSEC database in BIND backend, deleteTSIGKey(): " + e.txtReason());	×
495	}	×
496	return true;	×
497	}	×
498
499	bool Bind2Backend::getTSIGKeys(std::vector<struct TSIGKey>& keys)
500	{	×
501	if (!d_dnssecdb \|\| d_hybrid)	×
502	return false;	×
503
504	try {	×
505	d_getTSIGKeysQuery_stmt->execute();	×
506
507	SSqlStatement::row_t row;	×
508	while (d_getTSIGKeysQuery_stmt->hasNextRow()) {	×
509	d_getTSIGKeysQuery_stmt->nextRow(row);	×
510	struct TSIGKey key;	×
511	key.name = DNSName(row[0]);	×
512	key.algorithm = DNSName(row[1]);	×
513	key.key = row[2];	×
514	keys.push_back(key);	×
515	}	×
516
517	d_getTSIGKeysQuery_stmt->reset();	×
518	}	×
519	catch (SSqlException& e) {	×
520	throw PDNSException("Error accessing DNSSEC database in BIND backend, getTSIGKeys(): " + e.txtReason());	×
521	}	×
522	return true;	×
523	}	×
524
525	#endif

PowerDNS / pdns / 12947093256

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous