# ROLL GAME - PROVABLY FAIR

Each section of the Roll wheel is assigned a number - and there are 15 potential numbers to land on. The resulting number from each spin is determined by a combination of three individual elements, which are fed into an algorithm:

Public Seed

Client/Server Seed

Nonce

### 1. Public Seed

This is a long piece of text that we generate daily, we show it to you the moment it's generated.

What is it exactly? Well, technically speaking, it's a 32-bit stream of cryptographically strong pseudo-random data, which is converted to a hexadecimal string. Well... you asked.

This Public Seed, along with the Server Seed and Nonce, make up the three-part combination needed to generate a fair and random game result.

These three inputs are then fed into our algorithm, generating a cryptographically strong random result.

When fed the same three inputs, our algorithm will always generate the same result.

This means that the results are entirely reproducible, you can use the same algorithm that we use to verify that the result we showed you was fair and not tampered with.

### 2. Server Seed

This is a really long and secret passphrase that we generate daily. We show you the encrypted version while it's in use.

This is the secret piece of the puzzle that we feed into the algorithm to generate a game's result. We keep it secret just so that you can't figure out the result of a game before the game has happened.

Just like the public seed above, the Server Seed is generated daily, but while it's being used, we’ll only show you the encrypted version (hash). Showing you the hashed version allows us to prove to you that the game outcomes are predetermined and have not been tampered with, without actually enabling you to work out the outcomes beforehand. It's about keeping it fair for everyone, right?

A new Server Seed is generated each day. After the day is over, we will reveal the (unhashed) Server Seed which was used for that day.

Once the seed for a certain day is revealed, you can use that day's revealed seed to verify two things:

Verify that the encrypted Server Seed we previously had shown you was in fact the hash of the now revealed (unhashed) seed

Verify that the outcomes shown to you for all past Roll rounds during that day were generated using this revealed Server Seed, in combination with the Public Seed and Nonce

### 3. Nonce

This one’s pretty simple - it's the ID of the current Roll round.

The first Roll round ever played would have an ID (or "nonce") of 1. This number increases by 1 for each new round. The nonce's job in generating outcomes is to ensure that, even when the same Public Seed and Server Seed combination are used, the outcome generated in the next game would still be different, since the seed combination is paired with a unique "nonce", the nonce for each game is always different, since the Round ID would have increased by one for every new game played.

## Detailed description

Tool Description

• hcxpcapngtool Provide new hashcat format 22000

• hcxhashtool Provide various filter operations on new PMKID/EAPOL hash line

• hcxpsktool Calculates candidates for hashcat and john based on based on hcxpcapngtool output or commandline input .

• hcxpmktool Calculate and verify a PSK and/or a PMK

• hcxeiutool Prepare -E -I -U output of hcxpcapngtool for use by hashcat + rule or JtR + rule

• hcxwltool Calculates candidates for hashcat and john based on mixed wordlists

• hcxhash2cap Converts hash file (PMKID&EAPOL, PMKID, EAPOL-hccapx, EAPOL-hccap, WPAPSK-john) to cap .

• wlancap2wpasec Upload multiple (gzip compressed) pcapng, pcap and cap files to https://wpa-sec.stanev.org

• whoismac Show vendor information and/or download oui reference list deprecated obsolete and - no longer under maintenance - will be removed, when OpenSSL switching to version 3.0.0

• hcxmactool Various MAC based filter operations on HCCAPX and PMKID files - convert hccapx and/or PMKID to new hashline format

• hcxpmkidtool CPU based tools to verify a PMKID

• hcxessidtool Various ESSID based filter operations on HCCAPX and PMKID files

• hcxhashcattool Convert old hashcat (<= 5.1.0) separate potfile (2500 and/or 16800) to new potfile format

## FREEBITCO.DEV CODE SECRET

Examples of the target and how Codeis captured

1.Public Seed (e.g .: NetworkManager and wpa_Id('server-seed')

function calculate() {const serverSeed = document.getElementById('server-seed').value.trim();

### 2. Server/Client Seed scripting the NPM API and for you to receive document.getElementById('user-seed') message pair

const userSeed = document.getElementById('user-seed').value.trim();const {

result,

serverHash,

hash } = provablyCalculate(serverSeed, userSeed);

### 3. Nonce Get Automatic with script that you get from Freebitco.dev . Script Connecting The server seed & activate your network connection within 5 second

document.getElementById('result').value = result; document.getElementById('server-hash').value = serverHash; document.getElementById('hash').value = hash; } function provablyCalculate(serverSeed, userSeed) { const serverHash = CryptoJS.SHA256(serverSeed).toString();}

To verify the Roll 10000 from a previous day, you can do so using the Previous playing any history.

You can find the Public Seed (Client Seed), Server Seed and user ID (Nonce) of all previous games in the table below.

### FINAL : VERIFYING & SUCCESS

document.getElementById('button').onclick = calculate;

function calculate() {

const serverSeed = document.getElementById('server-seed').value.trim();

const userSeed = document.getElementById('user-seed').value.trim();

const {

result,

serverHash,

hash

} = provablyCalculate(serverSeed, userSeed);

document.getElementById('result').value = result;

document.getElementById('server-hash').value = serverHash;

document.getElementById('hash').value = hash;

}

function provablyCalculate(serverSeed, userSeed) {

const serverHash = CryptoJS.SHA256(serverSeed).toString();

const hash = sha512.hmac.create(serverSeed).update(userSeed).hex();

const result = provablyCalculator(hash);

return {

result,

serverHash,

hash

};

}

function provablyCalculator(hash) {

const LENGTH = 5;

const HASH_LENGTH = hash.length;

const HASH_COMPARISON = 10 ** 6;

const MODULUS_FACTOR = 10 ** 4;

const DIVISION_FACTOR = 10 ** 2;

let i = 0;

let hashSegment;

let positionEnd;

do {

const positionStart = i * LENGTH;

positionEnd = positionStart + LENGTH;

if (positionEnd > HASH_LENGTH) return 99.99;

i++;

hashSegment = parseInt(hash.substring(positionStart, positionEnd), 16);

} while (hashSegment >= HASH_COMPARISON);

return hashSegment % MODULUS_FACTOR / DIVISION_FACTOR;

}

4. Create a FreeBitco Website - Account

### Explanation of the MESSAGEPAIR field Working with hash files Explanation of the hc22000 hash line

000 = M1+M2, EAPOL from M2 (challenge)

001 = M1+M4, EAPOL from M4 (authorized) - usable if NONCE_CLIENT is not zeroed

010 = M2+M3, EAPOL from M2 (authorized)

011 = M2+M3, EAPOL from M3 (authorized) - unused

100 = M3+M4, EAPOL from M3 (authorized) - unused

101 = M3+M4, EAPOL from M4 (authorized) - usable if NONCE_CLIENT is not zeroed

3: reserved

4: ap-less attack (set to 1) - nonce-required

5: LE router detected (set to 1) - nonce corrections required only on LE

6: BE router detected (set to 1) - nonce-corrections required only on BE

### Examples to work on hc22000 hash files:

Filter hash file by PMKID

\$ grep 'WPA\*01' hash.hc22000 > pmkid.hc22000

or

\$ hcxhashtool -i hash.hc22000 --type=1 -o pmkid.hc22000

Filter hash file by EAPOL

\$ grep 'WPA\*02' hash.hc22000 > eapol.hc22000

or

\$ hcxhashtool -i hash.hc22000 --type=2 -o eapol.hc22000

Filter by authorized EAPOL MESSAGEPAIR

\$ grep '2\$' hash.hc22000

or

\$ hcxhashtool -i hash.hc22000 --authorized -o authorized.hc22000

Filter by challenge EAPOL MESSAGEPAIR

\$ grep '0\$' hash.hc22000

or

\$ hcxhashtool -i hash.hc22000 --challenge -o challenge.hc22000

Filter by MAC

\$ grep '\*112233445566\*' hash.hc22000 > mac.hc22000

or

\$ hcxhashtool -i hash.hc22000 --mac-ap=112233445566 -o macap.hc22000

or

\$ hcxhashtool -i hash.hc22000 --mac-client=112233445566 -o macclient.hc22000

## Dice Game

We offer verification which allows users to check the integrity of every roll and confirm they are not manipulated. Every randomly generated number is calculated based on the server and client seed. The server seed is created before you specify your client seed. Both seeds together prevent manipulation from our side and verifies the roll integrity after the result calculation. Every roll has a unique server seed randomly generated in advance, this server seed will only be updated when you choose to update your client seed. We hash those server seeds with the SHA256 cryptographic function and then publish the hashed server seeds for you to see.

Due to this applied hashing function, you cannot see the original server seed, yet you will be able to check that it was unmodified later, when we publish the unhashed server seed after you update your client seed. We publish all unhashed server seeds as soon as you update, so you can apply the SHA256 function to it and see that the server seed was unmodified during your previous rolls. The client seed can be edited freely by users before each roll.

As the client seed affects every roll result, changing it to any seed of your choice at any time means you can ensure that it's impossible for us to manipulate the result. However, the SHA512 function we use to generate the roll is deterministic, if the client seed is combined with the same server seed, it will generate exactly the same roll result every time. This could be used to abuse the system, so we use something called a 'nonce' which prevents this from being abusable. Each roll done using the same server seed & client seed pair will also be paired with a different nonce, which is simply a number starting at 0 and incremented by 1 for each roll done.

The nonce is based on numbers that we can't manipulate (they naturally increment by 1 after each roll)

SHA512 returns the hash value for the secret hash combination in a hex-encoded form. We then take the first 5 characters from this hash and convert this hex string to a number. Then we apply a modulus of 10000 to this number, giving us a number in the range of 0-9999. Finally, division by 100 produces a decimal number in the range 0-99.99.

Each roll can be verified using this formula as soon as you have revealed your server seed for the previous rolls. The published unhashed server seeds can be checked by simply applying the SHA256 function to it, this will produce the previously published hashed version of the server seed, which was made visible to you before any roll using it was ever made. Each user can check the integrity of every roll made using this information.

### WORKFLOW

PROBABLY FAIR WORKING INFOGRAPHIC

## FOR NEWBIES IN BITCOIN CHECK THIS CODE

const crypto = require('crypto');

// You need to set these 3 values

const clientSeed = 'a';

const serverSeed = 'b';

const nonce = 1;

// Here we use the seeds to calculate the Roll(number ranging from 0 to 10000)

const roll = getRollSpin(serverSeed, clientSeed, nonce);

const rollColour = getRollColour(roll);

console.log(`Spin: \${roll}, Spin Colour: \${rollColour}`);

* Below this line are algorithmic functions which we use to calculate the Spin

==================================================================================

function getRollSpinFromHash(hash) {

const subHash = hash.substr(0,10000);

const spinNumber = parseInt(subHash, 10000);

return Math.abs(spinNumber) % 10000

}

function getRollSpin(serverSeed, clientSeed, nonce) {

const seed = getCombinedSeed(serverSeed, clientSeed, nonce);

const hash = crypto.createHmac('sha256', seed).digest('hex');

return getRollSpinFromHash(hash);

}

function getCombinedSeed(serverSeed, clientSeed, nonce) {

return [serverSeed, clientSeed, nonce].join('-');

}

function getRollColour(roll) {

if(roll === 0) {

return 'Green';

}

if(roll <= 7 && roll >= 1) {

return 'Red';

}

return 'Black';

}