make openalias also available for solo miner; introduce namespace tools::dns_utils; support integrated address with dns lookup

1 files changed, 143 insertions, 0 deletions

diff --git a/src/common/dns_utils.cpp b/src/common/dns_utils.cpp
index e6e53a5c0..35fb9fe6c 100644
--- a/src/common/dns_utils.cpp
+++ b/src/common/dns_utils.cpp
@@ -26,7 +26,10 @@
 // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+#include "common/command_line.h"
+#include "common/i18n.h"
 #include "common/dns_utils.h"
+#include "cryptonote_core/cryptonote_basic_impl.h"
 #include <cstring>
 #include <sstream>
 // check local first (in the event of static or in-source compilation of libunbound)
@@ -323,4 +326,144 @@ bool DNSResolver::check_address_syntax(const char *addr) const
   return true;
 }
 
+namespace dns_utils
+{
+
+const char *tr(const char *str) { return i18n_translate(str, "tools::dns_utils"); }
+
+//-----------------------------------------------------------------------
+// TODO: parse the string in a less stupid way, probably with regex
+std::string address_from_txt_record(const std::string& s)
+{
+  // make sure the txt record has "oa1:xmr" and find it
+  auto pos = s.find("oa1:xmr");
+  if (pos == std::string::npos)
+    return {};
+  // search from there to find "recipient_address="
+  pos = s.find("recipient_address=", pos);
+  if (pos == std::string::npos)
+    return {};
+  pos += 18; // move past "recipient_address="
+  // find the next semicolon
+  auto pos2 = s.find(";", pos);
+  if (pos2 != std::string::npos)
+  {
+    // length of address == 95, we can at least validate that much here
+    if (pos2 - pos == 95)
+    {
+      return s.substr(pos, 95);
+    }
+    else if (pos2 - pos == 106) // length of address == 106 --> integrated address
+    {
+      return s.substr(pos, 106);
+    }
+  }
+  return {};
+}
+/**
+ * @brief gets a monero address from the TXT record of a DNS entry
+ *
+ * gets the monero address from the TXT record of the DNS entry associated
+ * with <url>.  If this lookup fails, or the TXT record does not contain an
+ * XMR address in the correct format, returns an empty string.  <dnssec_valid>
+ * will be set true or false according to whether or not the DNS query passes
+ * DNSSEC validation.
+ *
+ * @param url the url to look up
+ * @param dnssec_valid return-by-reference for DNSSEC status of query
+ *
+ * @return a monero address (as a string) or an empty string
+ */
+std::vector<std::string> addresses_from_url(const std::string& url, bool& dnssec_valid)
+{
+  std::vector<std::string> addresses;
+  // get txt records
+  bool dnssec_available, dnssec_isvalid;
+  std::string oa_addr = DNSResolver::instance().get_dns_format_from_oa_address(url);
+  auto records = DNSResolver::instance().get_txt_record(oa_addr, dnssec_available, dnssec_isvalid);
+
+  // TODO: update this to allow for conveying that dnssec was not available
+  if (dnssec_available && dnssec_isvalid)
+  {
+    dnssec_valid = true;
+  }
+  else dnssec_valid = false;
+
+  // for each txt record, try to find a monero address in it.
+  for (auto& rec : records)
+  {
+    std::string addr = address_from_txt_record(rec);
+    if (addr.size())
+    {
+      addresses.push_back(addr);
+    }
+  }
+  return addresses;
+}
+
+std::string get_account_address_as_str_from_url(const std::string& url, bool& dnssec_valid)
+{
+  // attempt to get address from dns query
+  auto addresses = addresses_from_url(url, dnssec_valid);
+  if (addresses.empty())
+  {
+    std::cout << tr("wrong address: ") << url;
+    return {};
+  }
+  // for now, move on only if one address found
+  if (addresses.size() > 1)
+  {
+    std::cout << tr("not yet supported: Multiple Monero addresses found for given URL: ") << url;
+    return {};
+  }
+  // prompt user for confirmation.
+  // inform user of DNSSEC validation status as well.
+  std::string dnssec_str;
+  if (dnssec_valid)
+  {
+    dnssec_str = tr("DNSSEC validation passed");
+  }
+  else
+  {
+    dnssec_str = tr("WARNING: DNSSEC validation was unsuccessful, this address may not be correct!");
+  }
+  std::stringstream prompt;
+  prompt << tr("For URL: ") << url
+         << ", " << dnssec_str << std::endl
+         << tr(" Monero Address = ") << addresses[0]
+         << std::endl
+         << tr("Is this OK? (Y/n) ")
+  ;  
+  // prompt the user for confirmation given the dns query and dnssec status
+  std::string confirm_dns_ok = command_line::input_line(prompt.str());
+  if (std::cin.eof())
+  {
+    return {};
+  }
+  if (!command_line::is_yes(confirm_dns_ok))
+  {
+    std::cout << tr("you have cancelled the transfer request") << std::endl;
+    return {};
+  }
+  return addresses[0];
+}
+
+bool get_account_address_from_str_or_url(
+    cryptonote::account_public_address& address
+  , bool& has_payment_id
+  , crypto::hash8& payment_id
+  , bool testnet
+  , const std::string& str_or_url
+  )
+{
+  if (cryptonote::get_account_integrated_address_from_str(address, has_payment_id, payment_id, testnet, str_or_url))
+    return true;
+  bool dnssec_valid;
+  std::string address_str = get_account_address_as_str_from_url(str_or_url, dnssec_valid);
+  return !address_str.empty() &&
+          cryptonote::get_account_integrated_address_from_str(address, has_payment_id, payment_id, testnet, address_str);
+}
+
+}  // namespace tools::dns_utils
+
 }  // namespace tools