Cryptocurrency address generator and validator (v1.0)



This webpage is created for educational purpose explaining how cryptocurrency public and private keys are generated.
All calculations are done in the browser using Javascript and no data is transmitted to any server. Verify this by inspecting the source code.

The following functionalities are implemented:
- Creating public keys (addresses) and private keys (uncompressed and compressed) for different cryptocurrencies (Bitcoin, Litecoin etc).
  All intermediate calculation steps can be seen by enabling checkbox "Show more details".
- Creating paper wallets including QR codes
- Creating vanity addresses

Symbol legend
|| : To indicate the concatenation of two strings on either side of the || symbol.
: The information should be kept secret.
: The information can be made public.

Select cryptocurrency network

Reset Clear all entered and calculated values.

Create random numbers
Choose one of the methods.
Method 1:
Auto generate cryptographically secure random numbers by pressing the "Generate" button or press the ESC key.

This tool uses two methods to generate cryptographic pseudorandom numbers depending if your browser supports it. The random numbers below are




Method 2:
Roll a 16 sided dice 64 times and enter its in sequential order:


  • Total number of combinations:
    2(32*8) = 2256 = 115,792,089,237,316,195,423,570,985,008,687,907,853,269,984,665,640,564,039,457,584,
    007,913,129,639,936 (78 digits or approximately 1077)
    The number of atoms in the entire observable universe is estimated to be within the range of 1078 to 1082

  • A valid random number must be in the interval [1, n - 1], where:
    n = FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
    See: secp256k1 elliptic curve domain parameters

  • If you use this method make sure the chosen numbers are truly random.
    One way is to use a 16 sided dice.



    If you only have one dice you need to roll it 64 times.
    If you have four dices (dice color blue, green, yellow and black) you need to roll them 16 times.
Method 3:
Enter password / passphrase.
Make it at least 16 characters long and use letters, numbers and special characters.
Random number = SHA256(SHA256(password / passphrase)))


  PrivateKey in different formats
 
  The random number is converted into a large hexadecimal value, 32 bytes or 64 characters (chars) long.
A valid PrivateKeyHex must be in the interval [1, n - 1], where:
n = FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
See: secp256k1 elliptic curve domain parameters
Look at method 2 and append each hexadecimal value, this will form the PrivateKeyHex value.
The PrivateKeyHex value is used to create the PrivateKey Wallet Import Format (WIF) Uncompressed or
PrivateKey Wallet Import Format (WIF) Compressed.
   
PrivateKeyHex chars
 
  The PrivateKeyHex value can also be encoded into a Base58 value.
It is similar to Base64 but has been modified to avoid both non-alphanumeric characters and letters which might
look ambiguous when printed. Compared to Base64, the following letters have been omitted from the alphabet:
0 (zero), O (capital o), I (capital i) and l (lower case L) as well as the non-alphanumeric characters + (plus) and
/ (slash). This number is not used within this tool and is only displayed here for educational purpose.
   
PrivateKeyBase58 chars
 
  The PrivateKeyHex value can also be encoded into a Base64 value.
This number is not used within this tool and is only displayed here for educational purpose.
   
PrivateKeyBase64 chars
 
  The 32 random numbers can also be converted into a comma separated decimal value string.
This number is not used within this tool and is only displayed here for educational purpose.
   
PrivateKeyDec    
 
  The PrivateKeyHex value can also be encoded into a binary value.
This value will be used to calculate the public key.
   
PrivateKeyBin chars  

  Calculate
PrivateKey Wallet Import Format (WIF) Uncompressed
 
  Each cryptocurrency privateKey has their own prefix version number (Bitcoin= 0x80, Litecoin=0xB0, etc).
Prepend this version number in front of the PrivateKeyHex value.
The prefix version number is always 1 byte in size and the PrivateKeyHex is 32 bytes.
The PrivateKeyVersion value is always (1+32=) 33 bytes or 66 characters long.
   
PrivateKeyVersion =
Version "
" || PrivateKeyHex
chars  
 
  Hash the PrivateKeyVersion value using the cryptographic hash function SHA256.
This Secure Hash Algorithm generates a 256-bit (32-byte) signature which cannot be decrypted back
to the original value (it is a one-way cryptographic function).
The HashA1 value is always 32 bytes or 64 characters long.
   
HashA1 =
SHA256(PrivateKeyVersion)
chars  
 
  Hash the HashA1 value using the same cryptographic hash function SHA256.
The HashA2 value is always 32 bytes or 64 characters long.
   
HashA2 =
SHA256(HashA1)
chars  
 
  Get the first 4 bytes (or first 8 characters) of the HashA2 value.
These 4 bytes is the checksum value which will be used to validate the address.
The ChecksumA value is always 4 bytes or 8 characters long.
   
ChecksumA
(first 4 bytes of HashA2)
chars  
 
  Append the ChecksumA value at the end of the PrivateKeyVersion value.
The PrivateKeyChecksum value is always (33+4=) 37 bytes or 74 characters long.
   
PrivateKeyChecksum = PrivateKeyVersion || ChecksumA chars  
 
  The PrivateKey Wallet Import Format (WIF) Uncompressed is the PrivateKeyChecksum value encoded into a
Base58 value. The PrivateKeyWIFUncompressed value must be kept secret and can be converted into QR codes
and can be printed on paper wallets.

If your software uses the PrivateKeyWIFUncompressed value, it also means you are the using the
PublicKeyUncompressed.

It is recommended to always to use the compressed public key (PublicKeyCompressed) and the compressed
private key (PrivateKeyWIFCompressed. If your software does not support the compressed keys you can use
the uncompressed public key (PublicKeyUncompressed) and uncompressed private key
(PrivateKeyWIFUncompressed).
   
PrivateKeyWIFUncompressed
= Base58(PrivateKeyChecksum)
chars

  Calculate
PrivateKey Wallet Import Format (WIF) Compressed
 
  Each cryptocurrency has their own prefix version number (Bitcoin= 0x80, Litecoin=0xB0, etc).
Prepend this version number in front of the PrivateKeyHex value and also append the value 0x01
to indicate that the private key is compressed. The prefix version number and compression flag
is always 1 byte in size and the PrivateKeyHex is 32 bytes.
The PrivateKeyVersionComp value is always (1+32+1=) 34 bytes or 68 characters long.
   
PrivateKeyVersionComp =
Version "
" || PrivateKeyHex || "01"
chars  
 
  Hash the PrivateKeyVersionComp value using the cryptographic hash function SHA256.
This Secure Hash Algorithm generates a 256-bit (32-byte) signature which cannot be decrypted back
to the original value (it is a one-way cryptographic function).
The HashB1 value is always 32 bytes or 64 characters long.
   
HashB1 = SHA256(PrivateKeyVersionComp) chars  
 
  Hash the HashB1 value using the same cryptographic hash function SHA256.
The HashB2 value is always 32 bytes or 64 characters long.
   
HashB2 = SHA256(HashB1) chars  
 
  Get the first 4 bytes (or first 8 characters) of the HashB2 value.
These 4 bytes is the checksum value which will be used to validate the address.
The ChecksumB value is always 4 bytes or 8 characters long.
   
ChecksumB (first 4 bytes of HashB2) chars  
 
  Append the ChecksumB value at the end of the PrivateKeyVersionComp value.
The PrivateKeyChecksumComp value is always (34+4=) 38 bytes or 76 characters long.
   
PrivateKeyChecksumComp = PrivateKeyVersionComp || ChecksumB chars  
 
  The PrivateKey Wallet Import Format (WIF) Compressed is the PrivateKeyChecksumComp value encoded into a
Base58 value. The PrivateKeyWIFCompressed value must be kept secret and can be converted into QR codes
and can be printed on paper wallets.

If your software uses the PrivateKeyWIFCompressed value, it also means you are the using the
PublicKeyCompressed.

It is recommended to always to use the compressed public key (PublicKeyCompressed) and the compressed
private key (PrivateKeyWIFCompressed. If your software does not support the compressed keys you can use
the uncompressed public key (PublicKeyUncompressed) and uncompressed private key
(PrivateKeyWIFUncompressed).
   
PrivateKeyWIFCompressed
= Base58(PrivateKeyChecksumComp)
chars

  Calculate
PublicKey
  Cryptocurrencies like Bitcoin or Litecoin, etc uses the Elliptic Curve (EC) to calculate the public keys.
Elliptic Curve Cryptography (ECC) was invented by Neal Koblitz and Victor Miller in 1985.
A 256-bit ECC public key should provide comparable security to a 3072-bit RSA public key thus less processing
power is required. Elliptic curves are called elliptic because of their relationship to elliptic
integrals in mathematics. Elliptic curves have nothing to do with ellipses. Ellipses are formed by quadratic
curves (x2). Elliptic curves are always cubic (x3).

Cryptocurrencies uses the following elliptic curve equation: y2 = x3 + ax + b

Elliptic curve domain parameters over Fp associated with a Koblitz curve secp256k1
Documented by the Standards for Efficient Cryptography Group (www.secg.org)
Parameter Value
a a is the constant that define the ellipc curve y2 = x3 + ax + b

a = 0

b b is the constant that define the ellipc curve y2 = x3 + ax + b

b = 7

p A finite field is a field with a finite number of elements, called its order (the size of the underlying set). The number of elements is the prime number p.
Fp is called the prime field of order p, and is the field of residue classes modulo p, where the p elements are denoted 0, ..., p - 1.
This means prime number p should be used for all the finite field math operations (better known as modulo operation), for example:
y2 mod p = (x3 + ax + b) mod p

The output of the math operation should never be bigger than the p value.

p = 2256 - 232 - 29 - 28 - 27 - 26 - 24 - 1 = 2256 - 232 - 977 =

Hexadecimal:
FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE FFFFFC2F

Decimal:
115792089237316195423570985008687907853269984665640564039457584007908834671663

G The base point G is a predetermined point (xG, yG) on the elliptic curve that everyone uses to compute other points on the curve.
Often the base point G is displayed in two ways:
  • Compressed form (prefix 02)
    02 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798

    If the prefix is removed, the value is the xG coordinate.
    To get the yG coordinate, calculate yG = (xG3 + 7 )1/2

  • Uncompressed form (prefix 04)
    04
    79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798
    483ADA77 26A3C465 5DA4FBFC 0E1108A8 FD17B448 A6855419 9C47D08F FB10D4B8

    If the prefix is removed, the first half of the value is the xG coordinate and the last half is the yG coordinate.
xG Hexadecimal:
79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798

Decimal:
55066263022277343669578718895168534326250603453777594175500187360389116729240

yG Hexadecimal:
483ADA77 26A3C465 5DA4FBFC 0E1108A8 FD17B448 A6855419 9C47D08F FB10D4B8

Decimal:
32670510020758816978083085130507043184471273380659243275938904335757337482424

n The prime n which is the order of base point G.

The parameter n determines which is the maximum value that can be turned into a Bitcoin private key. Any 256-bit number in the range [1, n - 1] is a valid private key.

Hexadecimal:
FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141

Decimal:
115792089237316195423570985008687907852837564279074904382605163141518161494337

Thus any 256-bit number from 0x1 to 0xFFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364140 is a valid private key.

h The cofactor: 01

Elliptic curve properties
  • If a line intersects two points P and Q, it intersects a third point on the curve -R.
  • If a line is tangent to the curve, it intersects another point on the curve.
  • All vertical lines intersects the curve at infinity.
Adding two distinct points P and Q on an elliptic curve (P ≠ Q)
  • Fig. 1 Geometry approach



    • Draw a straight line between P (x1, y1) and Q (x2, y2).
    • The line will intersect the elliptic curve at exactly one more point -R (x3, -y3).
    • The reflection of the point -R with respect to x-axis gives the point R (x3, y3), which is the results of
      addition of points P and Q.

  • Mathematical approach
    • The point slope form of the line:
      λ = ( y2 - y1 ) / ( x2 - x1 )
      λ ( x2 - x1 ) = ( y2 - y1 )

      Let ( x, y ) be any point on the curve. Repace (x2, y2) with ( x, y ):
      λ ( x - x1 ) = ( y - y1 )

    • The slope-intercept form of the line:
      λ ( x - x1 ) + y1 = y
      λx - λx1 + y1 = y
      λx + y1 - λx1 = y    [Equation 1]

      Create variable: β = y1 - λx1

      Implement variable β in Equation 1:
      y = λx + β    [Equation 2]

    • Finding coordinates point R (x3, y3):
      y = λx + β
      y2 = ( λx + β )2

      the ellipc curve: y2 = x3 + ax + b
      ( λx + β )2 = x3 + ax + b
      ( λx )2 + 2βλx + β2 = x3 + ax + b
      x3 + ax + b - ( λx )2 - 2βλx - β2 = 0
      x3 - λ2x2 + ax - 2βλx + b - β2 = 0
      x3 - λ2x2 + (a - 2βλ)x + (b - β2) = 0    [Equation 3]

      Equation 3 represents a monic polynomial, it means is that the coefficient of the highest power
      of x which is x3 is 1. A property of monic polynomials is that the sum of their roots (x1, x2, x3)
      is equal to the negative of the coefficient of the second highest power.
      Notice that the coefficient of x2 is -λ2, thus:
      x1 + x2 + x3 = λ2
      x3 = λ2 - x1 - x2

      x3 and y3 must be on the straight line y = λx + β:
      y3 = λx3 + β
      y3 = λx3 + (y1 - λx1)
      y3 = λ(x3 - x1) + y1

      Point -R has the coordinate (x3, -y3). The reflection of the point -R with respect to x-axis gives the
      point R (x3, y3), which is the results of addition of points P and Q.
      This means you need to multiple y3 with -1:
      y3 = λ(x1 - x3) - y1

    • Implement modulo p to limit points (xR, yR) in finite field Fp:
      A straight line will intersect an elliptic curve at three points P (x1, y1), Q (x2, y2) and -R (x3, -y3).
      The reflection of the point -R with respect to x-axis gives the point R (x3, y3), which is the result of
      addition of points P and Q.
      λ = ( y2 - y1 ) / ( x2 - x1 )
      x3 = λ2 - x1 - x2
      y3 = λ(x1 - x3) - y1

      Make point Q the same as the Generator point G (see secp256k1 elliptic curve domain
      parameters), repace point P coordinates (x1, y1) with ( x, y ) to indicate it can be any coordinate on
      the curve and R coordinates (x3, y3) with (xR, yR) the equations will look like:

      λ = ( yG - y ) / ( xG - x)
      xR = λ2 - x - xG
      yR = λ(x - xR) - y

      The last three math operations may output real numbers (ℝ).
      Real numbers are numbers that can be positive or negative and have decimal places after the point.
      Example: ℝ = {..., -5, -2.5, 0, 3, 6.334, ...}.
      In ECC we never work with real numbers only with integers (ℤ) so there are no inaccuraties
      due to rounding errors.
      Integers are positive numbers and have no decimal places after the point.
      Example: ℤ = {0, 1, 2, 3, ...}
      To make the calculations go faster a finite number of integers are to be used (Fp).
      The finite field (Fp) make working with curves a completely different concept.
      The curves when graphed over a finite field do not even resemble fig 1.
      When modulo p is applied, the equations of adding two points (ECAdd) will look like:

      λ = ( yG - y ) modinv( xG - x) (mod p)
      xR = λ2 - x - xG (mod p)
      yR = λ(x - xR) - y (mod p)

Doubling point P on an elliptic curve. Same as moving point Q to same location as point P (P = Q)
  • Fig. 2 Geometry approach



    • Draw a tangent line to the elliptic curve at point P.
    • The line intersects the elliptic curve at the point -R.
    • The reflection of the point -R with respect to x-axis gives the point R, which is the results of
      doubling of point P.

  • Mathematical approach
    • The slope of the tangent at a point P (x1, y1):
      The ellipc curve: y2 = x3 + ax + b
      2ydy = 3x2dx + a
      a = 0, see secp256k1 elliptic curve domain parameters
      2ydy = 3x2dx
      (2ydy)/dx = 3x2
      (dy/dx) = (3x2)/(2y)
      λ = (dy/dx)
      λ = (3x2)/(2y)
      λ = (3x12)/(2y1)

    • Finding coordinates point R (x3, y3):
      Equation 3 represents a monic polynomial, it means is that the coefficient of the highest power
      of x which is x3 is 1. A property of monic polynomials is that the sum of their roots (x1, x2, x3)
      is equal to the negative of the coefficient of the second highest power.
      Notice that the coefficient of x2 is -λ2, thus:
      x1 + x2 + x3 = λ2

      But point Q (x2, y2) is the same as point P (x1, y1), thus:
      x1 + x1 + x3 = λ2
      x3 = λ2 - 2x1

      x3 and y3 must be on the straight line (see Equation 2): y = λx + β:
      y3 = λx3 + β
      y3 = λx3 + (y1 - λx1)
      y3 = λ(x3 - x1) + y1

      Point -R has the coordinate (x3, -y3). The reflection of the point -R with respect to x-axis gives the
      point R (x3, y3), which is the results of doubling of point P.
      This means you need to multiple y3 with -1:
      y3 = λ(x1 - x3) - y1

    • Implement modulo p to limit points (xR, yR) in finite field Fp:
      The tangent line will intersect an elliptic curve at points P (x1, y1) and -R (x3, -y3).
      The reflection of the point -R with respect to x-axis gives the point R (x3, y3), which is the result of
      doubling of point P.
      λ = (3x12)/(2y1)
      x3 = λ2 - 2x1
      y3 = λ(x1 - x3) - y1

      Repace point P coordinates (x1, y1) with ( x, y ) to indicate it can be any coordinate on
      the curve and R coordinates (x3, y3) with (xR, yR) the equations will look like:

      λ = (3x2)/(2y)
      xR = λ2 - 2x
      yR = λ(x - xR) - y

      The last three math operations may output real numbers (ℝ).
      Real numbers are numbers that can be positive or negative and have decimal places after the point.
      Example: ℝ = {..., -5, -2.5, 0, 3, 6.334, ...}.
      In ECC we never work with real numbers only with integers (ℤ) so there are no inaccuraties
      due to rounding errors.
      Integers are positive numbers and have no decimal places after the point.
      Example: ℤ = {0, 1, 2, 3, ...}
      To make the calculations go faster a finite number of integers are to be used (Fp).
      The finite field (Fp) make working with curves a completely different concept.
      The curves when graphed over a finite field do not even resemble fig 2.
      When modulo p is applied, the equations of doubling a point (ECDouble) will look like:

      λ = (3x2) modinv(2y) (mod p)
      xR = λ2 - 2x (mod p)
      yR = λ(x - xR) - y (mod p)

Procedure to calculate x and y

Step Description
1 Get the Generator point G (xG, yG)
Get the number of points in the field: n
Get the PrivateKeyHex
2 if ( PrivateKeyHex >= n ) {
     Show error "PrivateKeyHex is too large."
} else {
     Continue with step 3
}
3 Convert PrivateKeyHex to PrivateKeyBin
4 i = 0
x = xG
y = yG
5 Point R (xR, yR) = ECDouble(x, y)
x = xR
y = yR
6 if ( PrivateKeyBin[ i ] == 1 ) {
     Point R (xR, yR) = ECAdd(x, y)
     x = xR
     y = yR
}
7 i = i + 1
8 if ( i < PrivateKeyBin.length ) {
     continue with step 5
}
9 x = xR
y = yR
   
 
  See Procedure to calculate x and y.
The x value is always 32 bytes or 64 characters long.
   
x chars  
 
  See Procedure to calculate x and y.
The y value is always 32 bytes or 64 characters long.
   
y chars  
 
  The PublicKey is the concatenation of the calculated x and y value.
The PublicKey is always 64 bytes or 128 characters long.
   
PublicKey =
x || y
chars  

  Calculate
PublicKey Uncompressed
 
  There are two types of PublickKeys, the compressed and uncompressed.
Prepend prefix value "04" in front of the PublickKey value to indicate that the PublickKey is uncompressed.
The prefix value is always 1 byte in size and the PublickKey is 64 bytes.
The PublicKeyVersion value is always (1+64=) 65 bytes or 130 characters long.


The public keys are either 33 bytes (PublicKey Compressed, PublicKeyVersionComp) or 65 bytes long
(PublicKey Uncompressed, PublicKeyVersion). Compressed keys only specify the x coordinate plus an 1 byte
flag indicating which side of the symmetrical curve the point is on, which allows y to be derived.
Uncompressed keys is represented by two coordinates (x, y) and there is a 1 byte prefix added.
Bitcoin originally only used uncompressed public keys, but since v0.6 compressed are now used.
It is recommended to use the compressed public keys (PublicKeyVersionComp) because they are smaller,
resulting in smaller transactions on the network, saving block chain size for everyone.
   
PublicKeyVersion =
"04" || PublicKey
chars  
 
  Hash the PublicKeyVersion value using the cryptographic hash function SHA256.
This Secure Hash Algorithm generates a 256-bit (32-byte) signature which cannot be decrypted back
to the original value (it is a one-way cryptographic function).
The HashC1 value is always 32 bytes or 64 characters long.
   
HashC1 =
SHA256(PublicKeyVersion)
chars  
 
  Hash the HashC1 value using the cryptographic hash function RIPEMD160.
The RIPEMD160 (RACE Integrity Primitives Evaluation Message Digest) generates a 160-bit (20-byte) signature
which cannot be decrypted back to the original value (it is a one-way cryptographic function).
The HashC2 value is always 20 bytes or 40 characters long.
   
HashC2 =
RIPEMD160(HashC1)
chars  
 
  Each cryptocurrency publicKey has their own prefix version number (Bitcoin= 0x00, Litecoin=0x30, etc).
Prepend this version number in front of the HashC2 value.
The prefix version number is always 1 byte in size and the HashC2 is 20 bytes.
The PublicKeyVersionHashC value is always (1+20=) 21 bytes or 42 characters long.
   
PublicKeyVersionHashC =
Version "
" || HashC2
chars  
 
  Hash the PublicKeyVersionHashC value using the cryptographic hash function SHA256.
This Secure Hash Algorithm generates a 256-bit (32-byte) signature which cannot be decrypted back
to the original value (it is a one-way cryptographic function).
The HashC3 value is always 32 bytes or 64 characters long.
   
HashC3 = SHA256(PublicKeyVersionHashC) chars  
 
  Hash the HashC3 value using the cryptographic hash function SHA256.
This Secure Hash Algorithm generates a 256-bit (32-byte) signature which cannot be decrypted back
to the original value (it is a one-way cryptographic function).
The HashC4 value is always 32 bytes or 64 characters long.
   
HashC4 = SHA256(HashC3) chars  
 
  Get the first 4 bytes (or first 8 characters) of the HashC4 value.
These 4 bytes is the checksum value which will be used to validate the address.
The ChecksumC value is always 4 bytes or 8 characters long.
   
ChecksumC (first 4 bytes of HashC4) chars  
 
  Append the ChecksumC value at the end of the PublicKeyVersionHashC value.
The PublicKeyChecksumC value is always (21+4=) 25 bytes or 50 characters long.
   
PublicKeyChecksumC = PublicKeyVersionHashC || ChecksumC chars  
 
  The Public Address Uncompressed is the PublicKeyChecksumC value encoded into a
Base58 value. The PublicKeyUncompressed value can be made public and can be converted into QR codes
and can be printed on paper wallets.

If your software uses the PrivateKeyWIFUncompressed value, it also means you are the using the
PublicKeyUncompressed.

It is recommended to always to use the compressed public key (PublicKeyCompressed) and the compressed
private key (PrivateKeyWIFCompressed. If your software does not support the compressed keys you can use
the uncompressed public key (PublicKeyUncompressed) and uncompressed private key
(PrivateKeyWIFUncompressed).

To check if a PublicKeyUncompressed has a valid checksum enter a new PublicKeyUncompressed address
and press the Validate button.
This button does not update previous values, for example PublicKeyChecksumC, ChecksumC, etc.
   
PublicKeyUncompressed
= Base58(PublicKeyChecksumC)
chars
  the
PublicKeyUncompressed address on Blockchain.info.
 

  Calculate
PublicKey Compressed
 
  If y is even, prefix value 02 (1 byte) is appended to value x.
If y is odd, prefix value 03 (1 byte) is appended to value x.
   
y is odd or even  
 
  The prefix value (1 byte) is appended to value x.
PublicKeyVersionComp is always (1 + 32) = 33 bytes or 66 characters long.

The public keys are either 33 bytes (PublicKey Compressed, PublicKeyVersionComp) or 65 bytes long
(PublicKey Uncompressed, PublicKeyVersion). Compressed keys only specify the x coordinate plus an 1 byte
flag indicating which side of the symmetrical curve the point is on, which allows y to be derived.
Uncompressed keys is represented by two coordinates (x, y) and there is a 1 byte prefix added.
Bitcoin originally only used uncompressed public keys, but since v0.6 compressed are now used.
It is recommended to use the compressed public keys (PublicKeyVersionComp) because they are smaller,
resulting in smaller transactions on the network, saving block chain size for everyone.
   
PublicKeyVersionComp =
Prefix || x
chars  
 
  Hash the PublicKeyVersionComp value using the cryptographic hash function SHA256.
This Secure Hash Algorithm generates a 256-bit (32-byte) signature which cannot be decrypted back
to the original value (it is a one-way cryptographic function).
The HashD1 value is always 32 bytes or 64 characters long.
   
HashD1 =
SHA256(PublicKeyVersionComp)
chars  
 
  Hash the HashD1 value using the cryptographic hash function RIPEMD160.
The RIPEMD160 (RACE Integrity Primitives Evaluation Message Digest) generates a 160-bit (20-byte) signature
which cannot be decrypted back to the original value (it is a one-way cryptographic function).
The HashD2 value is always 20 bytes or 40 characters long.
   
HashD2 =
RIPEMD160(HashD1)
chars  
 
  Each cryptocurrency publicKey has their own prefix version number (Bitcoin= 0x00, Litecoin=0x30, etc).
Prepend this version number in front of the HashD2 value.
The prefix version number is always 1 byte in size and the HashD2 is 20 bytes.
The PublicKeyVersionHashD value is always (1+20=) 21 bytes or 42 characters long.
   
PublicKeyVersionHashD =
Version "
" || HashD2
chars  
 
  Hash the PublicKeyVersionHashD value using the cryptographic hash function SHA256.
This Secure Hash Algorithm generates a 256-bit (32-byte) signature which cannot be decrypted back
to the original value (it is a one-way cryptographic function).
The HashD3 value is always 32 bytes or 64 characters long.
   
HashD3 = SHA256(PublicKeyVersionHashD) chars  
 
  Hash the HashD3 value using the cryptographic hash function SHA256.
This Secure Hash Algorithm generates a 256-bit (32-byte) signature which cannot be decrypted back
to the original value (it is a one-way cryptographic function).
The HashD4 value is always 32 bytes or 64 characters long.
   
HashD4 = SHA256(HashD3) chars  
 
  Get the first 4 bytes (or first 8 characters) of the HashD4 value.
These 4 bytes is the checksum value which will be used to validate the address.
The ChecksumD value is always 4 bytes or 8 characters long.
   
ChecksumD (first 4 bytes of HashD4) chars  
 
  Append the ChecksumD value at the end of the PublicKeyVersionHashD value.
The PublicKeyChecksumD value is always (21+4=) 25 bytes or 50 characters long.
   
PublicKeyChecksumD = PublicKeyVersionHashD || ChecksumD chars  
 
  The Public Address Compressed is the PublicKeyChecksumD value encoded into a
Base58 value. The PublicKeyCompressed value can be made public and can be converted into QR codes
and can be printed on paper wallets.

If your software uses the PrivateKeyWIFCompressed value, it also means you are the using the
PublicKeyCompressed.

It is recommended to always to use the compressed public key (PublicKeyCompressed) and the compressed
private key (PrivateKeyWIFCompressed. If your software does not support the compressed keys you can use
the uncompressed public key (PublicKeyUncompressed) and uncompressed private key
(PrivateKeyWIFUncompressed).

To check if a PublicKeyCompressed has a valid checksum enter a new PublicKeyCompressed address
and press the Validate button.
This button does not update previous values, for example PublicKeyChecksumD, ChecksumD, etc.
   
PublicKeyCompressed
= Base58(PublicKeyChecksumD)
chars
  the
PublicKeyCompressed address on Blockchain.info.
 

  Generate
Vanity PublicKey Uncompressed/Compressed
 
Vanity PublicKey
Uncompressed/Compressed
The
publicKey starts with prefix "
" vanity letters
The publicKey is and the vanity letters are
case sensitive
 
Total iterations  
Generated vanity publicKey

Public and Private keys QR codes

Make printer friendly page to create paper wallet
Public Address Uncompressed -
BITCOIN
Private Key (Wallet Import Format) Uncompressed -
BITCOIN
Share / Deposit / Verify
Secret

Public Address Compressed -
BITCOIN
Private Key (Wallet Import Format) Compressed -
BITCOIN
Share / Deposit / Verify
Secret

If you've found this tool useful feel free to send me a tip: BTC 18aiWtmkfVCpoXM7ADj6aRyCfoB6QjsZ3r




Disclaimer:

Use this tool at your own risk! All information on this page is provided "as is", without any warranty.
Mobilefish.com will not be liable for any damages, loss of profits or any other kind of loss you may sustain by using this tool.