Validate your certificate

Compute the SHA-256 hash of each individual file included in the project. There are many utilities for this. On Linux or macOS, run the following command in your terminal:

Terminal command:

Use a tool on your own computer rather than an online service: your files never need to leave your device.

SHA-256 is a standard algorithm - it will always produce the same result regardless of the tool used.

Remember to also hash the project cover file: a text file named "Cover - <Version ID>.txt" with the project title, description, project ID and version ID. The Bernstein app exports it for each certified version.

Combine the hashes into a single project fingerprint:

1. Sort all individual hashes alphabetically
2. Concatenate them into a single string
3. Compute the SHA-256 hash of the concatenated string

Or do all of it in one terminal command (protocol 2):

The result is your project fingerprint. You can verify it against the fingerprint shown in the Bernstein app under your project.

To use the project hash as a Bitcoin key, you need to convert it from HEX format to WIF (Wallet Import Format). We provide a Python script for this conversion.

Start by installing the required Python package:

Save the following Python script as hex2wif.py:

import sys, hashlib, base58

def hex_to_wif(hex_key):
    extended = "80" + hex_key + "01"
    first_sha = hashlib.sha256(bytes.fromhex(extended)).digest()
    second_sha = hashlib.sha256(first_sha).digest()
    checksum = second_sha[:4].hex()
    return base58.b58encode(bytes.fromhex(extended + checksum)).decode()

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Usage: python hex2wif.py <your-project-hash-hex>")
        sys.exit(1)
    print(hex_to_wif(sys.argv[1]))

Then run the script with your project hash:

The script will output the corresponding key in WIF format. You can verify the result in the Bernstein app by clicking the key icon next to the blockchain certificate in your project.

In this step, you need to derive the compressed public key from the WIF private key obtained in Step 2. This is a standard Bitcoin cryptographic operation.

Install the two Python packages the script below needs:

Save this Python script as wif2pub.py and run it with the WIF key from Step 2. It works offline, on your computer:

import sys, base58
from ecdsa import SECP256k1, SigningKey

raw = base58.b58decode_check(sys.argv[1])
assert raw[0] == 0x80 and len(raw) == 34 and raw[33] == 0x01, "not a compressed mainnet WIF key"
key = SigningKey.from_string(raw[1:33], curve=SECP256k1).get_verifying_key()
print(key.to_string("compressed").hex())

Paste the WIF key from Step 2 and the tool will display the associated compressed public key. This is the Data Public Key - one of the three keys that make up the certificate address.

Now that you have derived the Data Public Key from your files, combine it with the Owner Public Key and Bernstein Public Key - both found on the certificate PDF - to construct the 3-of-3 MultiSig Bitcoin address.

Install the two Ruby gems the script below needs:

Save and run the following Ruby script:

require 'digest'
require 'base58'
require 'bech32'

def decode_hex(hex)
  [hex].pack('H*')
end

def sha256(data)
  Digest::SHA256.digest(data)
end

def hash160(data)
  Digest::RMD160.digest(sha256(data))
end

# The 3-of-3 redeem script, keys in Bernstein's fixed order: owner, data, Bernstein. Do NOT sort them.
def redeem_script(keys)
  script = "\x53".b # OP_3
  keys.each { |k| script << [k.length / 2].pack('C') << decode_hex(k) }
  script << "\x53\xae".b # OP_3 OP_CHECKMULTISIG
end

# Legacy P2SH - addresses starting with 3
def p2sh_multisig(keys)
  payload = "\x05".b + hash160(redeem_script(keys))
  checksum = sha256(sha256(payload))[0..3]
  Base58.binary_to_base58(payload + checksum, :bitcoin)
end

# P2WSH (SegWit) - addresses starting with bc1q
def p2wsh_multisig(keys)
  segwit = Bech32::SegwitAddr.new
  segwit.hrp = 'bc'
  segwit.ver = 0
  segwit.prog = sha256(redeem_script(keys)).unpack('C*')
  segwit.addr
end

puts "Select the address type printed on your certificate:"
puts "1 - P2SH (legacy, address starts with 3)"
puts "2 - P2WSH (SegWit, address starts with bc1q)"
version = gets.chomp.to_i

keys = []
%w[Owner Data Bernstein].each do |name|
  print "Enter #{name} Public Key: "
  keys << gets.chomp
end

address = version == 1 ? p2sh_multisig(keys) : p2wsh_multisig(keys)
puts "\nBitcoin Address: #{address}"

Run the script from your terminal:

Follow the prompts: choose the address type printed on your certificate, then enter the Owner, Data and Bernstein public keys, in that order. Don't sort them: a different order gives a different address. The script outputs the Bitcoin address.

The address type is separate from the fingerprint protocol. Certificates since August 2018 use a SegWit P2WSH address (starting with bc1q), older ones a legacy P2SH address (starting with 3).

Finally, look up the Transaction ID from your certificate PDF on any blockchain explorer.

We recommend Blockstream.info orBlockchair.com.

Find the address in the transaction's output list and compare it with the address you computed in Step 4.

Congratulations - you have independently proven the existence and integrity of the information included in your project, without relying on any third party.