/** Change the name of the currently loaded wallet.
* \param new_name This should point to #NAME_LENGTH bytes (padded with
* spaces if necessary) containing the new desired name of
* the wallet.
* \return #WALLET_NO_ERROR on success, or one of #WalletErrorsEnum if an
* error occurred.
*/
WalletErrors changeWalletName(uint8_t *new_name)
{
WalletErrors r;
if (!wallet_loaded)
{
last_error = WALLET_NOT_THERE;
return last_error;
}
// Write wallet name.
if (nonVolatileWrite(new_name, OFFSET_NAME, NAME_LENGTH) != NV_NO_ERROR)
{
last_error = WALLET_WRITE_ERROR;
return last_error;
}
// Write checksum.
r = writeWalletChecksum();
if (r != WALLET_NO_ERROR)
{
last_error = r;
return last_error;
}
nonVolatileFlush();
last_error = WALLET_NO_ERROR;
return last_error;
}
/** Writes 4 byte wallet version. This is in its own function because
* it's used by both newWallet() and changeEncryptionKey().
* \return See #NonVolatileReturnEnum.
*/
static NonVolatileReturn writeWalletVersion(void)
{
uint8_t buffer[4];
if (isEncryptionKeyNonZero())
{
writeU32LittleEndian(buffer, VERSION_IS_ENCRYPTED);
}
else
{
writeU32LittleEndian(buffer, VERSION_UNENCRYPTED);
}
return nonVolatileWrite(buffer, OFFSET_VERSION, 4);
}
/** Wrapper around nonVolatileWrite() which also encrypts data
* using xexEncrypt(). Because this uses encryption, it is much slower
* than nonVolatileWrite(). The parameters and return values are identical
* to that of nonVolatileWrite().
* \param data A pointer to the data to be written.
* \param partition The partition to write to. Must be one of #NVPartitions.
* \param address Byte offset specifying where in the partition to
* start writing to.
* \param length The number of bytes to write.
* \return See #NonVolatileReturnEnum for return values.
* \warning Writes may be buffered; use nonVolatileFlush() to be sure that
* data is actually written to non-volatile storage.
*/
NonVolatileReturn encryptedNonVolatileWrite(uint8_t *data, NVPartitions partition, uint32_t address, uint32_t length)
{
uint32_t block_start;
uint32_t block_end;
uint8_t block_offset;
uint8_t ciphertext[16];
uint8_t plaintext[16];
uint8_t n[16];
NonVolatileReturn r;
block_start = address & 0xfffffff0;
block_offset = (uint8_t)(address & 0x0000000f);
block_end = (address + length - 1) & 0xfffffff0;
if ((address + length) < address)
{
// Overflow occurred.
return NV_INVALID_ADDRESS;
}
memset(n, 0, 16);
for (; block_start <= block_end; block_start += 16)
{
r = nonVolatileRead(ciphertext, partition, block_start, 16);
if (r != NV_NO_ERROR)
{
return r;
}
writeU32LittleEndian(n, block_start);
xexDecrypt(plaintext, ciphertext, n, 1);
while (length && block_offset < 16)
{
plaintext[block_offset++] = *data++;
length--;
}
block_offset = 0;
xexEncrypt(ciphertext, plaintext, n, 1);
r = nonVolatileWrite(ciphertext, partition, block_start, 16);
if (r != NV_NO_ERROR)
{
return r;
}
}
return NV_NO_ERROR;
}
/** Wrapper around nonVolatileWrite() which also encrypts data
* using xexEncrypt(). Because this uses encryption, it is much slower
* than nonVolatileWrite(). The parameters and return values are identical
* to that of nonVolatileWrite().
* \param data A pointer to the data to be written.
* \param address Byte offset specifying where in non-volatile storage to
* start writing to.
* \param length The number of bytes to write.
* \return See #NonVolatileReturnEnum for return values.
* \warning Writes may be buffered; use nonVolatileFlush() to be sure that
* data is actually written to non-volatile storage.
*/
NonVolatileReturn encryptedNonVolatileWrite(uint8_t *data, uint32_t address, uint8_t length)
{
uint32_t block_start;
uint32_t block_end;
uint8_t block_offset;
uint8_t ciphertext[16];
uint8_t plaintext[16];
uint8_t n[16];
NonVolatileReturn r;
block_start = address & 0xfffffff0;
block_offset = (uint8_t)(address & 0x0000000f);
block_end = (address + length - 1) & 0xfffffff0;
memset(n, 0, 16);
for (; block_start <= block_end; block_start += 16)
{
r = nonVolatileRead(ciphertext, block_start, 16);
if (r != NV_NO_ERROR)
{
return r;
}
writeU32LittleEndian(n, block_start);
xexDecrypt(plaintext, ciphertext, n, 1, nv_storage_tweak_key, nv_storage_encrypt_key);
while (length && block_offset < 16)
{
plaintext[block_offset++] = *data++;
length--;
}
block_offset = 0;
xexEncrypt(ciphertext, plaintext, n, 1, nv_storage_tweak_key, nv_storage_encrypt_key);
r = nonVolatileWrite(ciphertext, block_start, 16);
if (r != NV_NO_ERROR)
{
return r;
}
}
return NV_NO_ERROR;
}
int main(void)
{
uint8_t temp[128];
uint8_t address1[20];
uint8_t address2[20];
uint8_t name[NAME_LENGTH];
uint8_t encryption_key[WALLET_ENCRYPTION_KEY_LENGTH];
uint8_t new_encryption_key[WALLET_ENCRYPTION_KEY_LENGTH];
uint8_t version[4];
uint8_t *address_buffer;
uint8_t one_byte;
AddressHandle *handles_buffer;
AddressHandle ah;
PointAffine public_key;
PointAffine *public_key_buffer;
int abort;
int is_zero;
int abort_duplicate;
int abort_error;
int i;
int j;
initTests(__FILE__);
initWalletTest();
memset(encryption_key, 0, WALLET_ENCRYPTION_KEY_LENGTH);
setEncryptionKey(encryption_key);
// Blank out non-volatile storage area (set to all nulls).
temp[0] = 0;
for (i = 0; i < TEST_FILE_SIZE; i++)
{
fwrite(temp, 1, 1, wallet_test_file);
}
// sanitiseNonVolatileStorage() should nuke everything.
if (sanitiseNonVolatileStorage(0, 0xffffffff) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("Cannot nuke NV storage using sanitiseNonVolatileStorage()\n");
reportFailure();
}
// Check that the version field is "wallet not there".
if (getWalletInfo(version, temp) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("getWalletInfo() failed after sanitiseNonVolatileStorage() was called\n");
reportFailure();
}
if (readU32LittleEndian(version) == VERSION_NOTHING_THERE)
{
reportSuccess();
}
else
{
printf("sanitiseNonVolatileStorage() does not set version to nothing there\n");
reportFailure();
}
// initWallet() hasn't been called yet, so nearly every function should
// return WALLET_NOT_THERE somehow.
checkFunctionsReturnWalletNotThere();
// The non-volatile storage area was blanked out, so there shouldn't be a
// (valid) wallet there.
if (initWallet() == WALLET_NOT_THERE)
{
reportSuccess();
}
else
{
printf("initWallet() doesn't recognise when wallet isn't there\n");
reportFailure();
}
// Try creating a wallet and testing initWallet() on it.
memcpy(name, "123456789012345678901234567890abcdefghij", NAME_LENGTH);
if (newWallet(name) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("Could not create new wallet\n");
reportFailure();
}
if (initWallet() == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("initWallet() does not recognise new wallet\n");
reportFailure();
}
if ((getNumAddresses() == 0) && (walletGetLastError() == WALLET_EMPTY))
{
reportSuccess();
}
else
{
printf("New wallet isn't empty\n");
reportFailure();
}
// Check that the version field is "unencrypted wallet".
if (getWalletInfo(version, temp) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("getWalletInfo() failed after newWallet() was called\n");
reportFailure();
}
if (readU32LittleEndian(version) == VERSION_UNENCRYPTED)
{
reportSuccess();
}
else
{
printf("newWallet() does not set version to unencrypted wallet\n");
reportFailure();
}
// Check that sanitise_nv_wallet() deletes wallet.
if (sanitiseNonVolatileStorage(0, 0xffffffff) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("Cannot nuke NV storage using sanitiseNonVolatileStorage()\n");
reportFailure();
}
if (initWallet() == WALLET_NOT_THERE)
{
reportSuccess();
}
else
{
printf("sanitiseNonVolatileStorage() isn't deleting wallet\n");
reportFailure();
}
// Make some new addresses, then create a new wallet and make sure the
// new wallet is empty (i.e. check that newWallet() deletes existing
// wallet).
newWallet(name);
if (makeNewAddress(temp, &public_key) != BAD_ADDRESS_HANDLE)
{
reportSuccess();
}
else
{
printf("Couldn't create new address in new wallet\n");
reportFailure();
}
newWallet(name);
if ((getNumAddresses() == 0) && (walletGetLastError() == WALLET_EMPTY))
{
reportSuccess();
}
else
{
printf("newWallet() doesn't delete existing wallet\n");
reportFailure();
}
// Unload wallet and make sure everything realises that the wallet is
// not loaded.
if (uninitWallet() == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("uninitWallet() failed to do its basic job\n");
reportFailure();
}
checkFunctionsReturnWalletNotThere();
// Load wallet again. Since there is actually a wallet there, this
// should succeed.
if (initWallet() == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("uninitWallet() appears to be permanent\n");
reportFailure();
}
// Change bytes in non-volatile memory and make sure initWallet() fails
// because of the checksum check.
if (uninitWallet() != WALLET_NO_ERROR)
{
printf("uninitWallet() failed to do its basic job 2\n");
reportFailure();
}
abort = 0;
for (i = 0; i < WALLET_RECORD_LENGTH; i++)
{
if (nonVolatileRead(&one_byte, (uint32_t)i, 1) != NV_NO_ERROR)
{
printf("NV read fail\n");
abort = 1;
break;
}
one_byte++;
if (nonVolatileWrite(&one_byte, (uint32_t)i, 1) != NV_NO_ERROR)
{
printf("NV write fail\n");
abort = 1;
break;
}
if (initWallet() == WALLET_NO_ERROR)
{
printf("Wallet still loads when wallet checksum is wrong, offset = %d\n", i);
abort = 1;
break;
}
one_byte--;
if (nonVolatileWrite(&one_byte, (uint32_t)i, 1) != NV_NO_ERROR)
{
printf("NV write fail\n");
abort = 1;
break;
}
}
if (!abort)
{
reportSuccess();
}
else
{
reportFailure();
}
// Create 2 new wallets and check that their addresses aren't the same
newWallet(name);
if (makeNewAddress(address1, &public_key) != BAD_ADDRESS_HANDLE)
{
reportSuccess();
}
else
{
printf("Couldn't create new address in new wallet\n");
reportFailure();
}
newWallet(name);
memset(address2, 0, 20);
memset(&public_key, 0, sizeof(PointAffine));
if (makeNewAddress(address2, &public_key) != BAD_ADDRESS_HANDLE)
{
reportSuccess();
}
else
{
printf("Couldn't create new address in new wallet\n");
reportFailure();
}
if (memcmp(address1, address2, 20))
{
reportSuccess();
}
else
{
printf("New wallets are creating identical addresses\n");
reportFailure();
}
// Check that makeNewAddress() wrote to its outputs.
is_zero = 1;
for (i = 0; i < 20; i++)
{
if (address2[i] != 0)
{
is_zero = 0;
break;
}
}
if (is_zero)
{
printf("makeNewAddress() doesn't write the address\n");
reportFailure();
}
else
{
reportSuccess();
}
if (bigIsZero(public_key.x))
{
printf("makeNewAddress() doesn't write the public key\n");
reportFailure();
}
else
{
reportSuccess();
}
// Make some new addresses, up to a limit.
// Also check that addresses are unique.
newWallet(name);
abort = 0;
address_buffer = malloc(MAX_TESTING_ADDRESSES * 20);
for (i = 0; i < MAX_TESTING_ADDRESSES; i++)
{
if (makeNewAddress(&(address_buffer[i * 20]), &public_key) == BAD_ADDRESS_HANDLE)
{
printf("Couldn't create new address in new wallet\n");
abort = 1;
break;
}
for (j = 0; j < i; j++)
{
if (!memcmp(&(address_buffer[i * 20]), &(address_buffer[j * 20]), 20))
{
printf("Wallet addresses aren't unique\n");
abort = 1;
break;
}
}
if (abort)
{
break;
}
}
free(address_buffer);
if (!abort)
{
reportSuccess();
}
else
{
reportFailure();
}
// The wallet should be full now.
// Check that making a new address now causes an appropriate error.
if (makeNewAddress(temp, &public_key) == BAD_ADDRESS_HANDLE)
{
if (walletGetLastError() == WALLET_FULL)
{
reportSuccess();
}
else
{
printf("Creating a new address on a full wallet gives incorrect error\n");
reportFailure();
}
}
else
{
printf("Creating a new address on a full wallet succeeds (it's not supposed to)\n");
reportFailure();
}
// Check that getNumAddresses() fails when the wallet is empty.
newWallet(name);
if (getNumAddresses() == 0)
{
if (walletGetLastError() == WALLET_EMPTY)
{
reportSuccess();
}
else
{
printf("getNumAddresses() doesn't recognise wallet is empty\n");
reportFailure();
}
}
else
{
printf("getNumAddresses() succeeds when used on empty wallet\n");
reportFailure();
}
// Create a bunch of addresses in the (now empty) wallet and check that
// getNumAddresses() returns the right number.
address_buffer = malloc(MAX_TESTING_ADDRESSES * 20);
public_key_buffer = malloc(MAX_TESTING_ADDRESSES * sizeof(PointAffine));
handles_buffer = malloc(MAX_TESTING_ADDRESSES * sizeof(AddressHandle));
abort = 0;
for (i = 0; i < MAX_TESTING_ADDRESSES; i++)
{
ah = makeNewAddress(&(address_buffer[i * 20]), &(public_key_buffer[i]));
handles_buffer[i] = ah;
if (ah == BAD_ADDRESS_HANDLE)
{
printf("Couldn't create new address in new wallet\n");
abort = 1;
reportFailure();
break;
}
}
if (!abort)
{
reportSuccess();
}
if (getNumAddresses() == MAX_TESTING_ADDRESSES)
{
reportSuccess();
}
else
{
printf("getNumAddresses() returns wrong number of addresses\n");
reportFailure();
}
// The wallet should contain unique addresses.
abort_duplicate = 0;
for (i = 0; i < MAX_TESTING_ADDRESSES; i++)
{
for (j = 0; j < i; j++)
{
if (!memcmp(&(address_buffer[i * 20]), &(address_buffer[j * 20]), 20))
{
printf("Wallet has duplicate addresses\n");
abort_duplicate = 1;
reportFailure();
break;
}
}
}
if (!abort_duplicate)
{
reportSuccess();
}
// The wallet should contain unique public keys.
abort_duplicate = 0;
for (i = 0; i < MAX_TESTING_ADDRESSES; i++)
{
for (j = 0; j < i; j++)
{
if (bigCompare(public_key_buffer[i].x, public_key_buffer[j].x) == BIGCMP_EQUAL)
{
printf("Wallet has duplicate public keys\n");
abort_duplicate = 1;
reportFailure();
break;
}
}
}
if (!abort_duplicate)
{
reportSuccess();
}
// The address handles should start at 1 and be sequential.
abort = 0;
for (i = 0; i < MAX_TESTING_ADDRESSES; i++)
{
if (handles_buffer[i] != (AddressHandle)(i + 1))
{
printf("Address handle %d should be %d, but got %d\n", i, i + 1, (int)handles_buffer[i]);
abort = 1;
reportFailure();
break;
}
}
if (!abort)
{
reportSuccess();
}
// While there's a bunch of addresses in the wallet, check that
// getAddressAndPublicKey() obtains the same address and public key as
// makeNewAddress().
abort_error = 0;
abort = 0;
for (i = 0; i < MAX_TESTING_ADDRESSES; i++)
{
ah = handles_buffer[i];
if (getAddressAndPublicKey(address1, &public_key, ah) != WALLET_NO_ERROR)
{
printf("Couldn't obtain address in wallet\n");
abort_error = 1;
reportFailure();
break;
}
if ((memcmp(address1, &(address_buffer[i * 20]), 20))
|| (bigCompare(public_key.x, public_key_buffer[i].x) != BIGCMP_EQUAL)
|| (bigCompare(public_key.y, public_key_buffer[i].y) != BIGCMP_EQUAL))
{
printf("getAddressAndPublicKey() returned mismatching address or public key, ah = %d\n", i);
abort = 1;
reportFailure();
break;
}
}
if (!abort)
{
reportSuccess();
}
if (!abort_error)
{
reportSuccess();
}
// Test getAddressAndPublicKey() and getPrivateKey() functions using
// invalid and then valid address handles.
if (getAddressAndPublicKey(temp, &public_key, 0) == WALLET_INVALID_HANDLE)
{
reportSuccess();
}
else
{
printf("getAddressAndPublicKey() doesn't recognise 0 as invalid address handle\n");
reportFailure();
}
if (getPrivateKey(temp, 0) == WALLET_INVALID_HANDLE)
{
reportSuccess();
}
else
{
printf("getPrivateKey() doesn't recognise 0 as invalid address handle\n");
reportFailure();
}
if (getAddressAndPublicKey(temp, &public_key, BAD_ADDRESS_HANDLE) == WALLET_INVALID_HANDLE)
{
reportSuccess();
}
else
{
printf("getAddressAndPublicKey() doesn't recognise BAD_ADDRESS_HANDLE as invalid address handle\n");
reportFailure();
}
if (getPrivateKey(temp, BAD_ADDRESS_HANDLE) == WALLET_INVALID_HANDLE)
{
reportSuccess();
}
else
{
printf("getPrivateKey() doesn't recognise BAD_ADDRESS_HANDLE as invalid address handle\n");
reportFailure();
}
if (getAddressAndPublicKey(temp, &public_key, handles_buffer[0]) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("getAddressAndPublicKey() doesn't recognise valid address handle\n");
reportFailure();
}
if (getPrivateKey(temp, handles_buffer[0]) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("getPrivateKey() doesn't recognise valid address handle\n");
reportFailure();
}
free(address_buffer);
free(public_key_buffer);
free(handles_buffer);
// Check that changeEncryptionKey() works.
memset(new_encryption_key, 0, WALLET_ENCRYPTION_KEY_LENGTH);
new_encryption_key[0] = 1;
if (changeEncryptionKey(new_encryption_key) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("Couldn't change encryption key\n");
reportFailure();
}
// Check that the version field is "encrypted wallet".
if (getWalletInfo(version, temp) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("getWalletInfo() failed after changeEncryptionKey() was called\n");
reportFailure();
}
if (readU32LittleEndian(version) == VERSION_IS_ENCRYPTED)
{
reportSuccess();
}
else
{
printf("changeEncryptionKey() does not set version to encrypted wallet\n");
reportFailure();
}
// Check name matches what was given in newWallet().
if (!memcmp(temp, name, NAME_LENGTH))
{
reportSuccess();
}
else
{
printf("getWalletInfo() doesn't return correct name when wallet is loaded\n");
reportFailure();
}
// Check that getWalletInfo() still works after unloading wallet.
uninitWallet();
if (getWalletInfo(version, temp) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("getWalletInfo() failed after uninitWallet() was called\n");
reportFailure();
}
if (readU32LittleEndian(version) == VERSION_IS_ENCRYPTED)
{
reportSuccess();
}
else
{
printf("uninitWallet() caused wallet version to change\n");
reportFailure();
}
// Check name matches what was given in newWallet().
if (!memcmp(temp, name, NAME_LENGTH))
{
reportSuccess();
}
else
{
printf("getWalletInfo() doesn't return correct name when wallet is not loaded\n");
reportFailure();
}
// Change wallet's name and check that getWalletInfo() reflects the
// name change.
initWallet();
memcpy(name, "HHHHH HHHHHHHHHHHHHHHHH HHHHHHHHHHHHHH ", NAME_LENGTH);
if (changeWalletName(name) == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("changeWalletName() couldn't change name\n");
reportFailure();
}
getWalletInfo(version, temp);
if (!memcmp(temp, name, NAME_LENGTH))
{
reportSuccess();
}
else
{
printf("getWalletInfo() doesn't reflect name change\n");
reportFailure();
}
// Check that name change is preserved when unloading and loading a
// wallet.
uninitWallet();
getWalletInfo(version, temp);
if (!memcmp(temp, name, NAME_LENGTH))
{
reportSuccess();
}
else
{
printf("getWalletInfo() doesn't reflect name change after unloading wallet\n");
reportFailure();
}
// Check that initWallet() succeeds (changing the name changes the
// checksum, so this tests whether the checksum was updated).
if (initWallet() == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("initWallet() failed after name change\n");
reportFailure();
}
getWalletInfo(version, temp);
if (!memcmp(temp, name, NAME_LENGTH))
{
reportSuccess();
}
else
{
printf("getWalletInfo() doesn't reflect name change after reloading wallet\n");
reportFailure();
}
// Check that loading the wallet with the old key fails.
uninitWallet();
setEncryptionKey(encryption_key);
if (initWallet() == WALLET_NOT_THERE)
{
reportSuccess();
}
else
{
printf("Loading wallet with old encryption key succeeds\n");
reportFailure();
}
// Check that loading the wallet with the new key succeeds.
uninitWallet();
setEncryptionKey(new_encryption_key);
if (initWallet() == WALLET_NO_ERROR)
{
reportSuccess();
}
else
{
printf("Loading wallet with new encryption key fails\n");
reportFailure();
}
// Test the getAddressAndPublicKey() and getPrivateKey() functions on an
// empty wallet.
newWallet(name);
if (getAddressAndPublicKey(temp, &public_key, 0) == WALLET_EMPTY)
{
reportSuccess();
}
else
{
printf("getAddressAndPublicKey() doesn't deal with empty wallets correctly\n");
reportFailure();
}
if (getPrivateKey(temp, 0) == WALLET_EMPTY)
{
reportSuccess();
}
else
{
printf("getPrivateKey() doesn't deal with empty wallets correctly\n");
reportFailure();
}
fclose(wallet_test_file);
finishTests();
exit(0);
}
/** Create new wallet. A brand new wallet contains no addresses and should
* have a unique, unpredictable deterministic private key generation seed.
* \param name Should point to #NAME_LENGTH bytes (padded with spaces if
* necessary) containing the desired name of the wallet.
* \return #WALLET_NO_ERROR on success, or one of #WalletErrorsEnum if an
* error occurred. If this returns #WALLET_NO_ERROR, then the
* wallet will also be loaded.
* \warning This will erase the current one.
*/
WalletErrors newWallet(uint8_t *name)
{
uint8_t buffer[32];
WalletErrors r;
// Erase all traces of the existing wallet.
r = sanitiseNonVolatileStorage(0, WALLET_RECORD_LENGTH);
if (r != WALLET_NO_ERROR)
{
last_error = r;
return last_error;
}
// Write version.
if (writeWalletVersion() != NV_NO_ERROR)
{
last_error = WALLET_WRITE_ERROR;
return last_error;
}
// Write reserved area 1.
writeU32LittleEndian(buffer, 0);
if (nonVolatileWrite(buffer, OFFSET_RESERVED1, 4) != NV_NO_ERROR)
{
last_error = WALLET_WRITE_ERROR;
return last_error;
}
// Write name of wallet.
if (nonVolatileWrite(name, OFFSET_NAME, NAME_LENGTH) != NV_NO_ERROR)
{
last_error = WALLET_WRITE_ERROR;
return last_error;
}
// Write number of addresses.
writeU32LittleEndian(buffer, 0);
if (encryptedNonVolatileWrite(buffer, OFFSET_NUM_ADDRESSES, 4) != NV_NO_ERROR)
{
last_error = WALLET_WRITE_ERROR;
return last_error;
}
// Write nonce 1.
getRandom256(buffer);
if (encryptedNonVolatileWrite(buffer, OFFSET_NONCE1, 8) != NV_NO_ERROR)
{
last_error = WALLET_WRITE_ERROR;
return last_error;
}
// Write reserved area 2.
writeU32LittleEndian(buffer, 0);
if (encryptedNonVolatileWrite(buffer, OFFSET_RESERVED2, 4) != NV_NO_ERROR)
{
last_error = WALLET_WRITE_ERROR;
return last_error;
}
// Write seed for deterministic address generator.
getRandom256(buffer);
if (encryptedNonVolatileWrite(buffer, OFFSET_SEED, 32) != NV_NO_ERROR)
{
last_error = WALLET_WRITE_ERROR;
return last_error;
}
getRandom256(buffer);
if (encryptedNonVolatileWrite(buffer, OFFSET_SEED + 32, 32) != NV_NO_ERROR)
{
last_error = WALLET_WRITE_ERROR;
return last_error;
}
nonVolatileFlush();
// Write checksum.
r = writeWalletChecksum();
if (r != WALLET_NO_ERROR)
{
last_error = r;
return last_error;
}
nonVolatileFlush();
last_error = initWallet();
return last_error;
}
/** Sanitise (clear) a selected area of non-volatile storage. This will clear
* the area between start (inclusive) and end (exclusive).
* \param start The first address which will be cleared.
* \param end One byte past the last address which will be cleared.
* \return #WALLET_NO_ERROR on success, or one of #WalletErrorsEnum if an
* error occurred. This will still return #WALLET_NO_ERROR even if
* end is an address beyond the end of the non-volatile storage area.
* This is done so that using start = 0 and end = 0xffffffff will
* clear the entire non-volatile storage area.
* \warning start and end must be a multiple of 32 (unless start is 0 and
* end is 0xffffffff).
*/
WalletErrors sanitiseNonVolatileStorage(uint32_t start, uint32_t end)
{
uint8_t buffer[32];
uint32_t address;
NonVolatileReturn r;
uint8_t pass;
r = NV_NO_ERROR;
for (pass = 0; pass < 4; pass++)
{
address = start;
r = NV_NO_ERROR;
while ((r == NV_NO_ERROR) && (address < end))
{
if (pass == 0)
{
memset(buffer, 0, sizeof(buffer));
}
else if (pass == 1)
{
memset(buffer, 0xff, sizeof(buffer));
}
else
{
getRandom256(buffer);
}
r = nonVolatileWrite(buffer, address, 32);
nonVolatileFlush();
address += 32;
}
if ((r != NV_INVALID_ADDRESS) && (r != NV_NO_ERROR))
{
// Uh oh, probably an I/O error.
break;
}
} // end for (pass = 0; pass < 4; pass++)
if ((r == NV_INVALID_ADDRESS) || (r == NV_NO_ERROR))
{
// Write VERSION_NOTHING_THERE to all possible locations of the
// version field. This ensures that a wallet won't accidentally
// (1 in 2 ^ 31 chance) be recognised as a valid wallet by
// getWalletInfo().
writeU32LittleEndian(buffer, VERSION_NOTHING_THERE);
r = nonVolatileWrite(buffer, OFFSET_VERSION, 4);
if (r == NV_NO_ERROR)
{
last_error = WALLET_NO_ERROR;
}
else
{
last_error = WALLET_WRITE_ERROR;
}
}
else
{
last_error = WALLET_WRITE_ERROR;
}
return last_error;
}
