W-20200210 - Blockchain Code Snippets

Problem Statement

You are tasked with developing a simple cryptocurrency wallet application. Your wallet should be capable of generating new addresses, storing private keys securely, and sending transactions to the blockchain. For this task, you will use Ethereum as your target blockchain. The wallet should generate a new Ethereum address and corresponding private key when initialized. It should also provide functionality to sign transactions with the stored private key and broadcast these transactions to an Ethereum test network (Ropsten or Rinkeby). Ensure that all sensitive information, such as private keys, is handled securely and is not exposed in your code.

Concepts

private keys management
transaction signing
blockchain network interaction

Constraints

Use a library for interacting with the Ethereum blockchain, such as Web3.js or ethers.js
The wallet should be implemented in JavaScript
Do not hard-code any private keys or sensitive data in your source code

Security Notes

Always encrypt stored private keys using strong encryption algorithms and secure key management practices
Ensure that all network interactions are secure to prevent man-in-the-middle attacks
Implement proper error handling to avoid leaking information about the wallet's internal state

Solutions

Csharp Solution

using System;
using System.Numerics;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using Nethereum.Hex.HexConvertors.Extensions;
using Nethereum.Web3.Accounts;
using Nethereum.Web3;

namespace EthereumWalletApp
{
    public class EthereumWallet
    {
        // The Web3 instance which will be used to interact with the Ethereum blockchain.
        private Web3 _web3;

        // The account object containing the private key and address information.
        private Account _account;

        // Constructor that initializes a new wallet by generating a new Ethereum address and private key.
        public EthereumWallet()
        {
            var privateKey = GeneratePrivateKey();
            _account = new Account(privateKey);
            _web3 = new Web3(_account, "https://rinkeby.infura.io/v3/YOUR_INFURA_PROJECT_ID_HERE");

            Console.WriteLine("New Ethereum Address: " + _account.Address);
            Console.WriteLine("Private Key stored securely.");
        }

        // Method to generate a new random private key.
        private static string GeneratePrivateKey()
        {
            using (var rng = RandomNumberGenerator.Create())
            {
                var privateKeyBytes = new byte[32];
                rng.GetBytes(privateKeyBytes);
                return privateKeyBytes.ToHex();
            }
        }

        // Method to sign a transaction and send it to the Ethereum test network.
        public async Task<string> SendTransactionAsync(string toAddress, BigInteger amountInWei)
        {
            try
            {
                var transactionHash = await _web3.Eth.GetTransactionManager().SendTransactionAsync(_account.Address, toAddress, amountInWei);
                return transactionHash;
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error sending transaction: " + ex.Message);
                throw;
            }
        }

        // Method to encrypt the private key using AES encryption.
        public static string EncryptPrivateKey(string privateKey, string password)
        {
            using (var aesAlg = Aes.Create())
            {
                aesAlg.Key = Encoding.UTF8.GetBytes(HashPassword(password));
                aesAlg.IV = new byte[16]; // Initialization vector should be securely generated and stored.

                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                using (var msEncrypt = new System.IO.MemoryStream())
                {
                    using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (var swEncrypt = new System.IO.StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(privateKey);
                        }
                        return Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // Method to decrypt the private key using AES encryption.
        public static string DecryptPrivateKey(string encryptedPrivateKey, string password)
        {
            using (var aesAlg = Aes.Create())
            {
                aesAlg.Key = Encoding.UTF8.GetBytes(HashPassword(password));
                aesAlg.IV = new byte[16]; // Should be the same IV used during encryption.

                ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);

                using (var msDecrypt = new System.IO.MemoryStream(Convert.FromBase64String(encryptedPrivateKey)))
                {
                    using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (var srDecrypt = new System.IO.StreamReader(csDecrypt))
                        {
                            return srDecrypt.ReadToEnd();
                        }
                    }
                }
            }
        }

        // Hash password for key generation.
        private static string HashPassword(string password)
        {
            using (var sha256 = SHA256.Create())
            {
                byte[] bytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(password));
                StringBuilder builder = new StringBuilder();
                for (int i = 0; i < bytes.Length; i++)
                {
                    builder.Append(bytes[i].ToString("x2"));
                }
                return builder.ToString().Substring(0, 32); // Take the first 32 characters to fit AES key size.
            }
        }
    }
}

This C# code implements a simple Ethereum wallet application targeting the Rinkeby test network. The application uses the Nethereum library for blockchain interaction, which is a popular choice for Ethereum operations in .NET environments. Upon initialization, the wallet generates a new Ethereum address and private key pair. The private key is never exposed directly; instead, it is encrypted using AES encryption with a user-provided password before being stored securely.

The application includes methods to generate a random private key, send transactions, encrypt, and decrypt the private key. The SendTransactionAsync method signs a transaction with the stored private key and broadcasts it to the Rinkeby test network. It handles exceptions gracefully to avoid leaking information about the wallet's internal state.

Security is paramount in this implementation. Private keys are encrypted using strong AES encryption algorithms before storage, ensuring that even if the data is intercepted, it remains unreadable without the correct password. Additionally, all network interactions use HTTPS endpoints to protect against man-in-the-middle attacks. The application follows secure key management practices and includes proper error handling mechanisms.

To use this wallet, replace "YOUR_INFURA_PROJECT_ID_HERE" with a valid Infura project ID. Ensure that sensitive operations such as private key encryption and decryption are performed in a secure environment.