wallet: export and import keys as text (#49)

The last door out. Everything else assumes Berkeley DB will
cooperate. When it will not -- a build that cannot read the
file, a truncation, an environment past recovering -- the keys
are usually still perfectly intact and were unreachable
anyway. #40 is one person's account of exactly that, and #46
only rescues the cases where BDB still opens the file at all.

  bitflash -dumpwallet=keys.txt
  bitflash -importwallet=keys.txt

One key per line with its address and label. No database, no
environment, no version coupling: anything that can read a
line can recover from it.

The format is the DER private key in hex, which round-trips
exactly through SetPrivKey. Not interchangeable with other
wallets -- worth having eventually, but a WIF encoder I got
subtly wrong would be worse than no encoder at all, and this
file exists for the case where nothing else works.

Care taken, because the failure modes here cost money:

  - Refuses to overwrite an existing file. A mistyped path
    must not eat the only copy of something irreplaceable.
  - Written owner-only on POSIX, before any key reaches it.
    Windows inherits the folder's ACL; the README says so
    rather than pretending otherwise.
  - Newlines in labels are flattened, so a label cannot forge
    an extra entry on read-back.
  - Import skips keys already present, so running it twice
    does nothing, and one unreadable line is reported and
    stepped over instead of costing the reader every other key
    in the file.

Verified on Linux and Windows: a key exported from one wallet
imports into a different one and its address then appears
there; re-importing adds nothing; a corrupted line is skipped
while the rest still load; the dump is 0600 and refuses to
overwrite.

This does not solve #47. Keys still are not derived from a
seed, so a dump is as much a snapshot as any other backup.
What it does is make the keys reachable no matter what state
the database is in.

4 files changed, 255 insertions, 0 deletions

diff --git a/README.md b/README.md
index da8183a..16e979f 100644
--- a/README.md
+++ b/README.md
@@ -98,6 +98,30 @@ The second point is the pre-BIP32 problem that deterministic wallets were
 invented to solve; see [#47](https://github.com/Bitflash-sh/bitflash/issues/47).
 Until that lands, repetition is the only defence.
 
+### When wallet.dat itself will not open
+
+Everything above still runs through Berkeley DB. If the database is the thing
+that is broken — a build that will not read it, a file truncated by a bad copy,
+an environment beyond recovery — the keys are usually still fine, and you can
+take them out as text:
+
+```
+bitflash -dumpwallet=/path/to/keys.txt
+bitflash -importwallet=/path/to/keys.txt   # into any wallet, on any machine
+```
+
+One key per line with its address and label, no database and no environment.
+Importing skips keys the wallet already holds, so running it twice is safe, and
+an unreadable line is reported and stepped over rather than abandoning the rest.
+Restart the node afterwards so it scans the chain for transactions belonging to
+the new keys.
+
+**The dump is your private keys in the clear.** Anyone who reads that file can
+spend those coins. It is written owner-only on Linux and macOS; on Windows it
+inherits whatever the containing folder allows, so choose the folder carefully.
+Move it somewhere safe and delete the copy. `-dumpwallet` will not overwrite an
+existing file.
+
 ---
 
 ## Mining
diff --git a/src/db.cpp b/src/db.cpp
index fc5f180..4cc54ac 100644
--- a/src/db.cpp
+++ b/src/db.cpp
@@ -708,3 +708,194 @@ bool BackupWallet(const string& strDest)
     printf("BackupWallet() : wrote %s\n", strDest.c_str());
     return true;
 }
+
+
+// ---- plain-text key export/import ------------------------------------------
+//
+// The last door out. Everything else in this file assumes Berkeley DB will
+// cooperate; these two do not. A wallet.dat can be unreadable for reasons that
+// have nothing to do with your keys being gone -- a version this build does not
+// understand, a file truncated by a bad copy, an environment that cannot be
+// recovered -- and until now that meant the coins were unreachable even though
+// the secrets were sitting right there. Issue #40 is one person's account of
+// exactly that.
+//
+// The format is deliberately dull: a text file, one key per line, no database,
+// no environment, no framing. Anything that can read a line can recover from it.
+
+static int HexDigitValue(char c)
+{
+    if (c >= '0' && c <= '9') return c - '0';
+    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+    return -1;
+}
+
+static bool ParseHexInto(const string& str, vector<unsigned char>& vchRet)
+{
+    vchRet.clear();
+    if (str.empty() || (str.size() % 2) != 0)
+        return false;
+    for (size_t i = 0; i < str.size(); i += 2)
+    {
+        int hi = HexDigitValue(str[i]);
+        int lo = HexDigitValue(str[i + 1]);
+        if (hi < 0 || lo < 0)
+            return false;
+        vchRet.push_back((unsigned char)((hi << 4) | lo));
+    }
+    return true;
+}
+
+bool DumpWallet(const string& strDest)
+{
+    if (strDest.empty())
+        return error("DumpWallet() : no destination given\n");
+
+    // Never over an existing file. The whole point is to hold the only copy of
+    // something irreplaceable, and a mistyped path must not eat one.
+    if (FileExists(strDest.c_str()))
+        return error("DumpWallet() : %s already exists -- refusing to overwrite\n",
+                     strDest.c_str());
+
+    FILE* pf = fopen(strDest.c_str(), "w");
+    if (!pf)
+        return error("DumpWallet() : cannot write %s\n", strDest.c_str());
+#ifndef _WIN32
+    // Before a single key reaches it.
+    chmod(strDest.c_str(), S_IRUSR | S_IWUSR);
+#endif
+
+    fprintf(pf, "# Bitflash wallet key dump\n");
+    fprintf(pf, "# %s\n", DateTimeStr(GetTime()).c_str());
+    fprintf(pf, "#\n");
+    fprintf(pf, "# THIS FILE CONTAINS PRIVATE KEYS IN PLAIN TEXT.\n");
+    fprintf(pf, "# Anyone who reads it can spend these coins. Treat it as cash.\n");
+    fprintf(pf, "#\n");
+    fprintf(pf, "# One key per line:  <private-key-hex> <address> [label]\n");
+    fprintf(pf, "# The key is the DER encoding, hex; restore with -importwallet=FILE.\n");
+    fprintf(pf, "#\n");
+
+    int nKeys = 0;
+    bool fOk = true;
+    CRITICAL_BLOCK(cs_mapKeys)
+    {
+        for (map<vector<unsigned char>, CPrivKey>::iterator mi = mapKeys.begin();
+             mi != mapKeys.end(); ++mi)
+        {
+            const vector<unsigned char>& vchPubKey = (*mi).first;
+            const CPrivKey& vchPrivKey = (*mi).second;
+
+            string strAddress = PubKeyToAddress(vchPubKey);
+            string strLabel;
+            map<string, string>::iterator mia = mapAddressBook.find(strAddress);
+            if (mia != mapAddressBook.end())
+                strLabel = (*mia).second;
+
+            // Labels are user text and could contain a newline, which would
+            // forge a second entry on read-back.
+            for (size_t i = 0; i < strLabel.size(); i++)
+                if (strLabel[i] == '\n' || strLabel[i] == '\r')
+                    strLabel[i] = ' ';
+
+            if (fprintf(pf, "%s %s %s\n",
+                        HexStr(vchPrivKey.begin(), vchPrivKey.end(), false).c_str(),
+                        strAddress.c_str(),
+                        strLabel.c_str()) < 0)
+            { fOk = false; break; }
+            nKeys++;
+        }
+    }
+
+    if (fclose(pf) != 0)
+        fOk = false;
+    if (!fOk)
+    {
+        remove(strDest.c_str());
+        return error("DumpWallet() : writing %s failed\n", strDest.c_str());
+    }
+
+    printf("DumpWallet() : wrote %d key(s) to %s\n", nKeys, strDest.c_str());
+    return true;
+}
+
+bool ImportWallet(const string& strSrc, int& nAddedRet, int& nSkippedRet)
+{
+    nAddedRet = 0;
+    nSkippedRet = 0;
+
+    FILE* pf = fopen(strSrc.c_str(), "r");
+    if (!pf)
+        return error("ImportWallet() : cannot read %s\n", strSrc.c_str());
+
+    char buf[8192];
+    int nLine = 0;
+    int nBad = 0;
+    while (fgets(buf, sizeof(buf), pf))
+    {
+        nLine++;
+        string strLine = buf;
+        while (!strLine.empty() && (strLine[strLine.size()-1] == '\n' ||
+                                    strLine[strLine.size()-1] == '\r'))
+            strLine.resize(strLine.size() - 1);
+        if (strLine.empty() || strLine[0] == '#')
+            continue;
+
+        string strHex = strLine.substr(0, strLine.find(' '));
+        vector<unsigned char> vchPrivKey;
+        if (!ParseHexInto(strHex, vchPrivKey))
+        {
+            printf("ImportWallet() : line %d is not a hex key, skipped\n", nLine);
+            nBad++;
+            continue;
+        }
+
+        CKey key;
+        // A key this build cannot load is reported and stepped over rather than
+        // aborting the run: one damaged line in a salvage file must not cost
+        // the reader every other key in it.
+        try
+        {
+            CPrivKey vchSecure(vchPrivKey.begin(), vchPrivKey.end());
+            if (!key.SetPrivKey(vchSecure))
+            {
+                printf("ImportWallet() : line %d is not a usable key, skipped\n", nLine);
+                nBad++;
+                continue;
+            }
+        }
+        catch (const std::exception& e)
+        {
+            printf("ImportWallet() : line %d rejected (%s), skipped\n", nLine, e.what());
+            nBad++;
+            continue;
+        }
+
+        bool fHave = false;
+        CRITICAL_BLOCK(cs_mapKeys)
+            fHave = mapKeys.count(key.GetPubKey()) > 0;
+        if (fHave)
+        {
+            nSkippedRet++;   // already ours; importing twice is not an error
+            continue;
+        }
+
+        if (!AddKey(key))
+        {
+            fclose(pf);
+            return error("ImportWallet() : failed to store key from line %d\n", nLine);
+        }
+        nAddedRet++;
+    }
+    fclose(pf);
+
+    printf("ImportWallet() : %d added, %d already present, %d unreadable\n",
+           nAddedRet, nSkippedRet, nBad);
+
+    // Imported keys are only useful once their transactions are noticed, and
+    // that scan is a full pass over the chain the node does at startup.
+    if (nAddedRet > 0)
+        printf("ImportWallet() : restart the node so it can find transactions "
+               "belonging to the new keys\n");
+    return true;
+}
diff --git a/src/db.h b/src/db.h
index 987786c..22efc77 100644
--- a/src/db.h
+++ b/src/db.h
@@ -409,6 +409,13 @@ bool LoadWallet();
 // address created after this call are not spendable from the file it writes.
 bool BackupWallet(const string& strDest);
 
+// Plain-text key export/import: no Berkeley DB, no environment, no version
+// coupling. What you fall back on when wallet.dat itself will not cooperate.
+// DumpWallet refuses to overwrite an existing file and writes owner-only on
+// POSIX -- the output holds private keys in the clear.
+bool DumpWallet(const string& strDest);
+bool ImportWallet(const string& strSrc, int& nAddedRet, int& nSkippedRet);
+
 inline bool SetAddressBookName(const string& strAddress, const string& strName)
 {
     return CWalletDB().WriteName(strAddress, strName);
diff --git a/src/main_gui.cpp b/src/main_gui.cpp
index 976cd42..2484592 100644
--- a/src/main_gui.cpp
+++ b/src/main_gui.cpp
@@ -70,6 +70,9 @@ static void PrintUsage()
     printf("Wallet:\n");
     printf("  /backupwallet=FILE         (write a wallet.dat that opens on its own,\n");
     printf("                              then exit; run it again after new addresses)\n");
+    printf("  /dumpwallet=FILE           (export private keys as text -- readable by\n");
+    printf("                              anyone, so guard it like cash)\n");
+    printf("  /importwallet=FILE         (load keys from such a file back in)\n");
     printf("\n");
     printf("Each option also accepts '-' instead of '/'.\n");
 }
@@ -245,6 +248,36 @@ int main(int argc, char* argv[])
         return fOk ? 0 : 1;
     }
 
+    string strDump = argval2(argc, argv, "/dumpwallet", "-dumpwallet");
+    if (!strDump.empty())
+    {
+        bool fOk = DumpWallet(strDump);
+        if (fOk)
+        {
+            printf("Wrote %s\n", strDump.c_str());
+            printf("It holds your private keys as readable text. Anyone with the file "
+                   "can spend these coins -- keep it off shared storage and delete it "
+                   "once you have it somewhere safe.\n");
+        }
+        else
+            fprintf(stderr, "Export failed -- nothing was written.\n");
+        DBFlush(true);
+        return fOk ? 0 : 1;
+    }
+
+    string strImport = argval2(argc, argv, "/importwallet", "-importwallet");
+    if (!strImport.empty())
+    {
+        int nAdded = 0, nSkipped = 0;
+        bool fOk = ImportWallet(strImport, nAdded, nSkipped);
+        if (fOk)
+            printf("Imported %d key(s); %d were already here.\n", nAdded, nSkipped);
+        else
+            fprintf(stderr, "Import failed.\n");
+        DBFlush(true);
+        return fOk ? 0 : 1;
+    }
+
     ReacceptWalletTransactions();
 
     if (!StartNode(strErrors)) { fprintf(stderr,"StartNode: %s\n",strErrors.c_str()); return 1; }