Bitcoin private key converter

Bitcoin Private Key Finder

Free online tool for fast scanning random Bitcoin, Bitcoin Cash, Bitcoin SV, Litecoin, Dogecoin, Dash, Zcash private keys and finding addresses with balance.

How does it work?

Bitcoin Key Finder uses your CPU to generate private keys and check their balance without making heavy internet requests. Instead of checking the balance of each address, an address is matched against a database of funded addresses.

Why do I need it?

Instead of viewing the random private keys page and checking balances manually, you can use this tool to generate random private keys and check their balance automatically at high speed.

Which blockchains are supported?

Bitcoin Key Scanner supports Bitcoin, Bitcoin Cash, Bitcoin SV, Litecoin, Dogecoin, Dash, Zcash, Ethereum blockchains.

How many addresses are in the database?

Our scanner’s database contains about 7,000,000 funded addresses:

• Bitcoin addresses with the balance greater or equal 0.01 BTC;
• Bitcoin Cash addresses with the balance greater or equal 1 BCH;
• Bitcoin SV addresses with the balance greater or equal 1 BSV;
• Litecoin addresses with the balance greater or equal 1 LTC;
• Dogecoin addresses with the balance greater or equal 100,000 DOGE;
• Dash addresses with the balance greater or equal 1 DASH;
• Zcash addresses with the balance greater or equal 1 ZEC;
• Top 1,000,000 richest Ethereum addresses.

Why does it may find addresses with zero balance?

Private Key Finder uses a space-efficient probabilistic data structure to store funded addresses. It has a compact size, but it may produce false positives. In other words, Finder shows addresses that possibly have balance.

Is it possible to use my GPU to generate private keys too?

Currently, it’s not possible to make complex GPU calculations in JavaScript. But you can use BitCrack.

Has anyone ever found a funded Bitcoin private key?

The scanner found an address with the balance. What’s next?

A found balance will be paid to the payout address specified. Payouts are made manually ASAP.

What is the service fee?

30% will be subtracted from the found balance before payout as a service fee.

Источник

Bitcoin Private Key Finder

Free online tool for fast scanning random Bitcoin, Bitcoin Cash, Bitcoin SV, Litecoin, Dogecoin, Dash, Zcash private keys and finding addresses with balance.

How does it work?

Bitcoin Key Finder uses your CPU to generate private keys and check their balance without making heavy internet requests. Instead of checking the balance of each address, an address is matched against a database of funded addresses.

Why do I need it?

Instead of viewing the random private keys page and checking balances manually, you can use this tool to generate random private keys and check their balance automatically at high speed.

Which blockchains are supported?

Bitcoin Key Scanner supports Bitcoin, Bitcoin Cash, Bitcoin SV, Litecoin, Dogecoin, Dash, Zcash, Ethereum blockchains.

How many addresses are in the database?

Our scanner’s database contains about 7,000,000 funded addresses:

• Bitcoin addresses with the balance greater or equal 0.01 BTC;
• Bitcoin Cash addresses with the balance greater or equal 1 BCH;
• Bitcoin SV addresses with the balance greater or equal 1 BSV;
• Litecoin addresses with the balance greater or equal 1 LTC;
• Dogecoin addresses with the balance greater or equal 100,000 DOGE;
• Dash addresses with the balance greater or equal 1 DASH;
• Zcash addresses with the balance greater or equal 1 ZEC;
• Top 1,000,000 richest Ethereum addresses.

Why does it may find addresses with zero balance?

Private Key Finder uses a space-efficient probabilistic data structure to store funded addresses. It has a compact size, but it may produce false positives. In other words, Finder shows addresses that possibly have balance.

Is it possible to use my GPU to generate private keys too?

Currently, it’s not possible to make complex GPU calculations in JavaScript. But you can use BitCrack.

Has anyone ever found a funded Bitcoin private key?

The scanner found an address with the balance. What’s next?

A found balance will be paid to the payout address specified. Payouts are made manually ASAP.

What is the service fee?

30% will be subtracted from the found balance before payout as a service fee.

Источник

Bitcoin private key converter

Tool for converting Bitcoin keys and addresses

Use Git or checkout with SVN using the web URL.

Work fast with our official CLI. Learn more.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

README.md

bitcoin-tool is a simple tool written in C to convert Bitcoin keys to addresses, and various other conversions of keys.

Disclaimer: THIS CODE IS EXPERIMENTAL, IT IS PROBABLY BUGGY. PLEASE DO NOT TRUST YOUR BITCOINS WITH IT. IT IS EASY TO MAKE AN IRREVERSIBLE MISTAKE AND SEND YOUR BITCOINS TO A ADDRESS WITH NO WAY OF GETTING THEM BACK.

Run make test to compile and run all tests.

• A C compiler
• OpenSSL headers and libraries (with elliptic curve support)
• GNU make : Packages: FreeBSD gmake
• GNU bash (for running tests)
• xxd (for running tests) : Packages: Linux vim , FreeBSD vim or vim-lite

Gentoo by default enables the bindist flag on the openssl package, which disables elliptic curve support, presumably because of software patent concerns. Since the openssh package also has bindist USE-flag set, the USE-flag must be disabled in both, then re-emerged to get an OpenSSL library with elliptic curve support.

Use gmake to process the Makefile.

• FreeBSD 10.4 amd64, clang 3.4.1
• FreeBSD 11.1 amd64, clang 4.0.0

Tested on Windows 10 64-bit edition using Cygwin (64-bit) with x86_64_w64_mingw32-gcc compiler.

Requires Cygwin packages: bash , make , mingw64-x86_64-gcc-core , openssl-devel

Use make CC=other_cc to specify a different compiler if needed.

I created this because I couldn’t find an offline tool or library able to create addresses from Bitcoin private keys, and as a learning exercise in Bitcoin address formats and ECDSA.

Some day I’d like to replace the dependancy on OpenSSL with my own implementation of ECDSA (for portability).

The option names are a little verbose but I wanted to make it clear exactly what each one is referring to, especially when it is possible to make a costly mistake.

I’ve tried to add as much sanity checking as possible, to remove the scope for errors and misinterpretation of data. This sometimes boreders on the pedantic and annoying. For example, if the file for —input-file contains more data than is expected, then it’ll refuse to process it at all.

The mini-private-key input-type requires —input to be a 30 character ASCII string in valid mini private key format and —input-format to be raw .

If raw keys are input and an address output is required, then the key type prefix must be specified via —network

Manual address / key generation

Let’s manually generate a Bitcoin address and private key for the purpose of an offline wallet (cold storage).

Create private key:

Inspect private key:

Convert private key to WIF (Wallet Import Format). Since it is a raw key, the network type must be explicitally set (to bitcoin in this case) because it cannot be determined from the raw key :

Specifying —public-key-compression is mandatory because the WIF output is different depending on which public key compression type you choose, and there is no way to guess from a raw private key.

Same again but compressed public key :

Note that the WIF private key is longer with public key compression on, because an extra byte flag is stored to indicate that the public key should be compressed (the private key is exactly the same).

Show address for uncompressed WIF private key:

Show address for compressed WIF private key:

This demonstrates why it is necessary to be careful when converting raw private keys to addresses; the same private key will (almost definitely) result in two seperate addresses, one for each intermediate form of the public key.

Convert the WIF private key to a QR code so we can print it and import it easily later:

Now you can receive Bitcoins using the address above, but you will need to import the private key into your wallet at a later time in order to spend them ( bitcoind importprivkey , for the official client), or at least be able to sign transactions with that key (not necessarily online).

Generate address from random private key

This outputs an address you can send Bitcoins to, if you want to loose them forever (because the private key is never output!).

Hash a text phrase with SHA256, which is then used as the private key to generate an address from.

Never use this example for an actual wallet, it will be stolen almost immediately! (I did a test with another dictionary word and it took all of 4 seconds for someone to steal it!)

This shows the —output-type all option, which spews out lots of unnecessary garbage which I can’t imagine would ever be useful, but it does so because it can. So There.

You can read multiple lines of input from a text file and process individually with the —batch option. This requires the —input-file option to be set. This will be faster than spawning a new instance of bitcoin-tool for each line of a line — from a shell script, for example.

Generate 1000 random private keys in hex format keys=1000 ; openssl rand $[32*keys] | xxd -p -c32 > hexkeys

Convert all the private keys to addresses

Источник

How to generate your very own Bitcoin private key

In cryptocurrencies, a private key allows a user to gain access to their wallet. The person who holds the private key fully controls the coins in that wallet. For this reason, you should keep it secret. And if you really want to generate the key yourself, it makes sense to generate it in a secure way.

Here, I will provide an introduction to private keys and show you how you can generate your own key using various cryptographic functions. I will provide a description of the algorithm and the code in Python.

Do I need to generate a private key?

Most of the time you don’t. For example, if you use a web wallet like Coinbase or Blockchain.info, they create and manage the private key for you. It’s the same for exchanges.

Mobile and desktop wallets usually also generate a private key for you, although they might have the option to create a wallet from your own private key.

So why generate it anyway? Here are the reasons that I have:

• You want to make sure that no one knows the key
• You just want to learn more about cryptography and random number generation (RNG)

What exactly is a private key?

Formally, a private key for Bitcoin (and many other cryptocurrencies) is a series of 32 bytes. Now, there are many ways to record these bytes. It can be a string of 256 ones and zeros (32 * 8 = 256) or 100 dice rolls. It can be a binary string, Base64 string, a WIF key, mnemonic phrase, or finally, a hex string. For our purposes, we will use a 64 character long hex string.

The same private key, written in different formats.

Why exactly 32 bytes? Great question! You see, to create a public key from a private one, Bitcoin uses the ECDSA, or Elliptic Curve Digital Signature Algorithm. More specifically, it uses one particular curve called secp256k1.

Now, this curve has an order of 256 bits, takes 256 bits as input, and outputs 256-bit integers. And 256 bits is exactly 32 bytes. So, to put it another way, we need 32 bytes of data to feed to this curve algorithm.

There is an additional requirement for the private key. Because we use ECDSA, the key should be positive and should be less than the order of the curve. The order of secp256k1 is FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 , which is pretty big: almost any 32-byte number will be smaller than it.

Naive method

So, how do we generate a 32-byte integer? The first thing that comes to mind is to just use an RNG library in your language of choice. Python even provides a cute way of generating just enough bits:

Looks good, but actually, it’s not. You see, normal RNG libraries are not intended for cryptography, as they are not very secure. They generate numbers based on a seed, and by default, the seed is the current time. That way, if you know approximately when I generated the bits above, all you need to do is brute-force a few variants.

When you generate a private key, you want to be extremely secure. Remember, if anyone learns the private key, they can easily steal all the coins from the corresponding wallet, and you have no chance of ever getting them back.

So let’s try to do it more securely.

Cryptographically strong RNG

Along with a standard RNG method, programming languages usually provide a RNG specifically designed for cryptographic operations. This method is usually much more secure, because it draws entropy straight from the operating system. The result of such RNG is much harder to reproduce. You can’t do it by knowing the time of generation or having the seed, because there is no seed. Well, at least the user doesn’t enter a seed — rather, it’s created by the program.

In Python, cryptographically strong RNG is implemented in the secrets module. Let’s modify the code above to make the private key generation secure!

That is amazing. I bet you wouldn’t be able to reproduce this, even with access to my PC. But can we go deeper?

Specialized sites

There are sites that generate random numbers for you. We will consider just two here. One is random.org, a well-known general purpose random number generator. Another one is bitaddress.org, which is designed specifically for Bitcoin private key generation.

Can random.org help us generate a key? Definitely, as they have service for generating random bytes. But two problems arise here. Random.org claims to be a truly random generator, but can you trust it? Can you be sure that it is indeed random? Can you be sure that the owner doesn’t record all generation results, especially ones that look like private keys? The answer is up to you. Oh, and you can’t run it locally, which is an additional problem. This method is not 100% secure.

Now, bitaddress.org is a whole different story. It’s open source, so you can see what’s under its hood. It’s client-side, so you can download it and run it locally, even without an Internet connection.

So how does it work? It uses you — yes, you — as a source of entropy. It asks you to move your mouse or press random keys. You do it long enough to make it infeasible to reproduce the results.

The process of generation an entropy by randomly moving the mouse. The large chunk of symbols shows the pool.

Are you interested to see how bitaddress.org works? For educational purposes, we will look at its code and try to reproduce it in Python.

Quick note: bitaddress.org gives you the private key in a compressed WIF format, which is close to the WIF format that we discussed before. For our purposes, we will make the algorithm return a hex string so that we can use it later for a public key generation.

Bitaddress: the specifics

Bitaddress creates the entropy in two forms: by mouse movement and by key pressure. We’ll talk about both, but we’ll focus on the key presses, as it’s hard to implement mouse tracking in the Python lib. We’ll expect the end user to type buttons until we have enough entropy, and then we’ll generate a key.

Bitaddress does three things. It initializes byte array, trying to get as much entropy as possible from your computer, it fills the array with the user input, and then it generates a private key.

Bitaddress uses the 256-byte array to store entropy. This array is rewritten in cycles, so when the array is filled for the first time, the pointer goes to zero, and the process of filling starts again.

The program initiates an array with 256 bytes from window.crypto. Then, it writes a timestamp to get an additional 4 bytes of entropy. Finally, it gets such data as the size of the screen, your time zone, information about browser plugins, your locale, and more. That gives it another 6 bytes.

After the initialization, the program continually waits for user input to rewrite initial bytes. When the user moves the cursor, the program writes the position of the cursor. When the user presses buttons, the program writes the char code of the button pressed.

Finally, bitaddress uses accumulated entropy to generate a private key. It needs to generate 32 bytes. For this task, bitaddress uses an RNG algorithm called ARC4. The program initializes ARC4 with the current time and collected entropy, then gets bytes one by one 32 times.

This is all an oversimplification of how the program works, but I hope that you get the idea. You can check out the algorithm in full detail on Github.

Doing it yourself

For our purposes, we’ll build a simpler version of bitaddress. First, we won’t collect data about the user’s machine and location. Second, we will input entropy only via text, as it’s quite challenging to continually receive mouse position with a Python script (check PyAutoGUI if you want to do that).

That brings us to the formal specification of our generator library. First, it will initialize a byte array with cryptographic RNG, then it will fill the timestamp, and finally it will fill the user-created string. After the seed pool is filled, the library will let the developer create a key. Actually, they will be able to create as many private keys as they want, all secured by the collected entropy.

Initializing the pool

Here we put some bytes from cryptographic RNG and a timestamp. __seed_int and __seed_byte are two helper methods that insert the entropy into our pool array. Notice that we use secrets .

Seeding with input

Here we first put a timestamp and then the input string, character by character.

Generating the private key

This part might look hard, but it’s actually very simple.

First, we need to generate 32-byte number using our pool. Unfortunately, we can’t just create our own random object and use it only for the key generation. Instead, there is a shared object that is used by any code that is running in one script.

What does that mean for us? It means that at each moment, anywhere in the code, one simple random.seed(0) can destroy all our collected entropy. We don’t want that. Thankfully, Python provides getstate and setstate methods. So, to save our entropy each time we generate a key, we remember the state we stopped at and set it next time we want to make a key.

Second, we just make sure that our key is in range (1, CURVE_ORDER ). This is a requirement for all ECDSA private keys. The CURVE_ORDER is the order of the secp256k1 curve, which is FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 .

Finally, for convenience, we convert to hex, and strip the ‘0x’ part.

In action

Let’s try to use the library. Actually, it’s really simple: you can generate a private key in three lines of code!

You can see it yourself. The key is random and totally valid. Moreover, each time you run this code, you get different results.

Conclusion

As you can see, there are a lot of ways to generate private keys. They differ in simplicity and security.

Generating a private key is only a first step. The next step is extracting a public key and a wallet address that you can use to receive payments. The process of generating a wallet differs for Bitcoin and Ethereum, and I plan to write two more articles on that topic.

If you want to play with the code, I published it to this Github repository.

I am making a course on cryptocurrencies here on freeCodeCamp News. The first part is a detailed description of the blockchain.

I also post random thoughts about crypto on Twitter, so you might want to check it out.

Read more posts by this author.

If you read this far, tweet to the author to show them you care. Tweet a thanks

Learn to code for free. freeCodeCamp’s open source curriculum has helped more than 40,000 people get jobs as developers. Get started

freeCodeCamp is a donor-supported tax-exempt 501(c)(3) nonprofit organization (United States Federal Tax Identification Number: 82-0779546)

Our mission: to help people learn to code for free. We accomplish this by creating thousands of videos, articles, and interactive coding lessons — all freely available to the public. We also have thousands of freeCodeCamp study groups around the world.

Donations to freeCodeCamp go toward our education initiatives and help pay for servers, services, and staff.

Источник