tor: Add option to encrypt Tor private key

This commit lays the groundwork for enabling the option of encrypting a Tor private key on disk, and removes the onion type parameters from the OnionStore interface methods, since they are unused.

tor/cmd_onion_test.go

@@ -1,8 +1,8 @@
 package tor
 
 import (
-	"bytes"
 	"errors"
+	"io"
 	"path/filepath"
 	"testing"
 
@@ -10,40 +10,61 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// TestOnionFile tests that the OnionFile implementation of the OnionStore
+var (
+	privateKey = []byte("RSA1024 hide_me_plz")
+	anotherKey = []byte("another_key")
+)
+
+// TestOnionFile tests that the File implementation of the OnionStore
 // interface behaves as expected.
 func TestOnionFile(t *testing.T) {
 	t.Parallel()
 
-	privateKey := []byte("hide_me_plz")
-	privateKeyPath := filepath.Join(t.TempDir(), "secret")
+	tempDir := t.TempDir()
+	privateKeyPath := filepath.Join(tempDir, "secret")
+	mockEncrypter := MockEncrypter{}
 
 	// Create a new file-based onion store. A private key should not exist
 	// yet.
-	onionFile := NewOnionFile(privateKeyPath, 0600)
-	if _, err := onionFile.PrivateKey(V2); err != ErrNoPrivateKey {
-		t.Fatalf("expected ErrNoPrivateKey, got \"%v\"", err)
-	}
+	onionFile := NewOnionFile(
+		privateKeyPath, 0600, false, mockEncrypter,
+	)
+	_, err := onionFile.PrivateKey()
+	require.ErrorIs(t, err, ErrNoPrivateKey)
 
 	// Store the private key and ensure what's stored matches.
-	if err := onionFile.StorePrivateKey(V2, privateKey); err != nil {
-		t.Fatalf("unable to store private key: %v", err)
-	}
-	storePrivateKey, err := onionFile.PrivateKey(V2)
-	require.NoError(t, err, "unable to retrieve private key")
-	if !bytes.Equal(storePrivateKey, privateKey) {
-		t.Fatalf("expected private key \"%v\", got \"%v\"",
-			string(privateKey), string(storePrivateKey))
-	}
+	err = onionFile.StorePrivateKey(privateKey)
+	require.NoError(t, err)
+
+	storePrivateKey, err := onionFile.PrivateKey()
+	require.NoError(t, err)
+	require.Equal(t, storePrivateKey, privateKey)
 
 	// Finally, delete the private key. We should no longer be able to
 	// retrieve it.
-	if err := onionFile.DeletePrivateKey(V2); err != nil {
-		t.Fatalf("unable to delete private key: %v", err)
-	}
-	if _, err := onionFile.PrivateKey(V2); err != ErrNoPrivateKey {
-		t.Fatal("found deleted private key")
-	}
+	err = onionFile.DeletePrivateKey()
+	require.NoError(t, err)
+
+	_, err = onionFile.PrivateKey()
+	require.ErrorIs(t, err, ErrNoPrivateKey)
+
+	// Create a new file-based onion store that encrypts the key this time
+	// to ensure that an encrypted key is properly handled.
+	encryptedOnionFile := NewOnionFile(
+		privateKeyPath, 0600, true, mockEncrypter,
+	)
+
+	err = encryptedOnionFile.StorePrivateKey(privateKey)
+	require.NoError(t, err)
+
+	storedPrivateKey, err := encryptedOnionFile.PrivateKey()
+	require.NoError(t, err, "unable to retrieve encrypted private key")
+	// Check that PrivateKey returns anotherKey, to make sure the mock
+	// decrypter is actually called.
+	require.Equal(t, storedPrivateKey, anotherKey)
+
+	err = encryptedOnionFile.DeletePrivateKey()
+	require.NoError(t, err)
 }
 
 // TestPrepareKeyParam checks that the key param is created as expected.
@@ -63,7 +84,7 @@ func TestPrepareKeyParam(t *testing.T) {
 
 	// Create a mock store which returns the test private key.
 	store := &mockStore{}
-	store.On("PrivateKey", cfg.Type).Return(testKey, nil)
+	store.On("PrivateKey").Return(testKey, nil)
 
 	// Check that the test private is returned.
 	cfg = AddOnionConfig{Type: V3, Store: store}
@@ -75,7 +96,7 @@ func TestPrepareKeyParam(t *testing.T) {
 
 	// Create a mock store which returns ErrNoPrivateKey.
 	store = &mockStore{}
-	store.On("PrivateKey", cfg.Type).Return(nil, ErrNoPrivateKey)
+	store.On("PrivateKey").Return(nil, ErrNoPrivateKey)
 
 	// Check that the V3 keyParam is returned.
 	cfg = AddOnionConfig{Type: V3, Store: store}
@@ -87,7 +108,7 @@ func TestPrepareKeyParam(t *testing.T) {
 
 	// Create a mock store which returns an dummy error.
 	store = &mockStore{}
-	store.On("PrivateKey", cfg.Type).Return(nil, dummyErr)
+	store.On("PrivateKey").Return(nil, dummyErr)
 
 	// Check that an error is returned.
 	cfg = AddOnionConfig{Type: V3, Store: store}
@@ -158,14 +179,14 @@ func TestPrepareAddOnion(t *testing.T) {
 		tc := tc
 
 		if tc.cfg.Store != nil {
-			store.On("PrivateKey", tc.cfg.Type).Return(
+			store.On("PrivateKey").Return(
 				testKey, tc.expectedErr,
 			)
 		}
 
 		controller := NewController("", tc.targetIPAddress, "")
 		t.Run(tc.name, func(t *testing.T) {
-			cmd, err := controller.prepareAddOnion(tc.cfg)
+			cmd, _, err := controller.prepareAddOnion(tc.cfg)
 			require.Equal(t, tc.expectedErr, err)
 			require.Equal(t, tc.expectedCmd, cmd)
 
@@ -184,20 +205,27 @@ type mockStore struct {
 // interface.
 var _ OnionStore = (*mockStore)(nil)
 
-func (m *mockStore) StorePrivateKey(ot OnionType, key []byte) error {
-	args := m.Called(ot, key)
+func (m *mockStore) StorePrivateKey(key []byte) error {
+	args := m.Called(key)
 	return args.Error(0)
 }
 
-func (m *mockStore) PrivateKey(ot OnionType) ([]byte, error) {
-	args := m.Called(ot)
-	if args.Get(0) == nil {
-		return nil, args.Error(1)
-	}
-	return args.Get(0).([]byte), args.Error(1)
+func (m *mockStore) PrivateKey() ([]byte, error) {
+	args := m.Called()
+	return []byte("hide_me_plz"), args.Error(1)
 }
 
-func (m *mockStore) DeletePrivateKey(ot OnionType) error {
-	args := m.Called(ot)
+func (m *mockStore) DeletePrivateKey() error {
+	args := m.Called()
 	return args.Error(0)
 }
+
+type MockEncrypter struct{}
+
+func (m MockEncrypter) EncryptPayloadToWriter(_ []byte, _ io.Writer) error {
+	return nil
+}
+
+func (m MockEncrypter) DecryptPayloadFromReader(_ io.Reader) ([]byte, error) {
+	return anotherKey, nil
+}