joshirio / iota-cooler Goto Github PK

IOTAcooler, the IOTA Cold Transaction Signer

License: MIT License

QMake 1.35% C++ 83.53% HTML 12.65% Inno Setup 1.97% Shell 0.50%

iota cold-storage iota-wallet multisig cold-wallets

iota-cooler's Introduction

IOTAcooler

A cross-platform cold storage and spending wallet for IOTA. At its core, IOTAcooler uses standard IOTA multisig addresses to split the signing process over two devices, one online (hot signer) and the other offline (cold signer). In this way, the offline signing seed is never exposed to the internet, securing your funds against popular attack vectors exploited by malware. For best security, consider running IOTAcooler from a live linux image while cold signing a transaction. Please check out our user guide for additional security considerations and a quick software tour.

IOTAcooler is designed with security and speed in mind. All sensitive steps are done completely offline, including the wallet recovery feature. IOTAcooler is really fast because the wallet is stateful, meaning that all past transactions, addresses and other states are saved into the wallet file, also because it uses light IOTA API requests for checking current transfers on the Tangle, which is very practical in case numerous or big transactions are part of the wallet history. The downside of this is that some specific information for incoming transactions is only visible on a tangle explorer.

The multisig signing is handled by iotacooler-smidgen, based on smidgen. Smidgen is a nodejs command line multisig utility, created by Bitfinex, which uses the official IOTA javascript library.

Features

Wallet encryption (AES-256) with password. Wallet file never stores the offline signing key.
Multiple receiving addresses per transaction (batching)
Address reuse detection when sending to addresses with outgoing transfers, even after snapshots
Snapshot proof wallet recovery from seeds with offline signing process (recovery seeds remain safe)
Two step transaction signing, online and offline
Clipboard guard to warn about possible unwanted changes (malware) to copied addresses
Support for custom generated seeds
Built-in promote and reattach utility
Fast transaction history retrieval, even with big bundles (DevIOTA Field donations :)
Remote proof-of-work: fast transactions and less power usage
Detect and warn if an old wallet version is opened

Limitations

Only one receiving address a time. A new address is generated automatically on transfers. You can use traditional spending wallets with small amounts which then are periodically refilled from secure cold storage wallets.
Requires to always backup the wallet file after each transfer. Store and sync it in the cloud to be safe (wallet is encrypted and doesn't hold the offline signing key). If an old version is opened by mistake, IOTAcooler will detect this and show a warning.
Some information, like source addresses for incoming transfers, is only visible with a tangle explorer due to light API requests usage.

How it looks

Demo video

Click here for a short YouTube demo

Download

IOTAcooler works on Windows, macOS and Linux. Visit the releases page and download the appropriate executable/installer for your OS. For Arch Linux based distributions, there's also an AUR package for building from source, this is also the most secure option, since you don't have to trust the precompiled binaries.

Building from source

Clone the source repository and compile with

git clone --recurse-submodules https://github.com/joshirio/iota-cooler.git
cd iota-cooler
qmake -config release
make

To run, iotacooler-smidgen is required. iotacooler-smidgen is a fork of smidgen with added functionality like promoting, address reuse checking on multisig transfers, custom recovery commands and changes to allow building nodejs binaries with pkg. See deployment for building and packaging steps. Please also check out the PKGBUILD script as an example.

User Guide

The project wiki includes an user guide and other useful information.

License

MIT, see LICENSE file.

Support this project

Donate IOTA

iota-cooler's People

Contributors

Stargazers

Watchers

Forkers

prudhviraj-500

iota-cooler's Issues

Add a tag field

Ability to add a tag to a transaction

Add ability to provide custom generated seeds on wallet creation

For advanced users who want to generate their own seeds it makes sense to provide an option to enter the seeds while creating a wallet offline.

Example of dice seeds:

AppImage fails to run on Qt 5.11

See giowck/symphytum#59 as the same issue fixed by rebuilding the image with an updated Qt and AppImage setup.

Use new default node

With carrIOTA being down, better switch to https://thetangle.org/nodes
Doesn't provide auto promote and reattach though.

Compress wallet data

Especially the smidgen multisig file.

Save list of incoming transactions for current address during snapshot

Currently the history of an address is saved to the wallet file permanently only after an outgoing transaction, which implies that the address will never be used again, since that would trigger an address reuse.

Currently, if a snapshot happens, an unspent address will lose its incoming transactions history, since nodes drop all transactions after a snapshot.

It makes sense to always store the latest transaction in the wallet file under a temporary position that is added to the wallet file permanently if a snapshot has been detected.

It is necessary to find a reliable way to detect a snapshot, because sometimes broken nodes report zero transactions for a given address.

Maybe add mnemonic (BIP39) support for iota seeds

Open to discuss if implementing mnemonic seeds make sense.

We could use the already existing python iota mnemonic lib:
https://github.com/mlouielu/iota-mnemonic

The downside is that there's not a standard for IOTA seeds yet, so this could cause incompatibilities with other multisig softwares. IOTAcooler could include a converter (accessible through the tools menu) to solve this.

But since the user is highly unlikely to type the seed by keyboard for each transaction, we can assume that most users copy and paste the seed (from keepass, for example) on the offline singing device anyway, so the benefits are limited.

AppImage does not run

Getting AppRun: Permission denied.

References:

Provide snap package

Creating a snap package for publishing on https://snapcraft.io/store would add a range of linux distro support and even other architectures (ARM).

Clipboard guard infinite loop on macOS

When a change is detected the warning message keeps spawning over and over.

Show full value transfers in history, in addition to outgoing txs

iotacooler-smidgen was adapted to retrieve full transaction history for a specific address. This is useful to store and show all past value transactions, including incoming transfers. A big issue is that the API call is crazy slow, especially for addresses with transfers involving big bundles (see carriota field donations).

So a quick "transfer retrieval" call was added to iotacooler-smidgen, which doesn't include the source addresses though, but at least it is usable and fast. I think if someone needs those, clicking the tangle explorer button is not too hard.

Maybe I could offer an option in the settings dialog to use the precise but slow method, if required...

Provide PGP signatures

To enhance security providing PGP signature of the releases would be beneficial, also for automated build script like PKGBUILD that can verify signatures.

Public key should be added to docs in code AND on github wiki.

Wallet recovery from multisig seeds

Add a wallet recovery dialog.

Recovering funds from the two multisig seeds (online, offline) involves generating all addresses until wereAddressesSpentFrom returns false and then checking the balance.

The funds should be transferred to a newly created wallet.

Ideally, this should also happen offline, the problem with this is that checking balances offline is not possible, meaning that the software needs to generate in advance, for example, 200 addresses and then it is checked online. But in case the address count was exceeded, the wallet would require to generate another batch of addresses, which is cumbersome but the only way.

An easier way would be to just to it online, but this exposes the seeds for short time to the internet.

I'm leaning towards the offline solution, since it's more secure and users usually generate less than 200 addresses...