When you open the fairness panel on a box site, the hashed server seed is a long line of letters and numbers. On some sites that line is 64 characters long, on others it is 128. That length is the tell: a 64-character hash means the site committed with SHA-256, and a 128-character hash means it used SHA-512. Both belong to the same family of hash functions, both are one-way, and for the thing you actually care about, checking that a completed pull was honest, the choice between them changes nothing. This page explains what sha256 vs sha512 really means for a case-opening result, so you can read either one with confidence.
Two fingerprints, different lengths
A hash is a one-way fingerprint. You feed in a value, like a site's secret server seed, and out comes a fixed-length string that stands in for it. It is easy to go from the seed to the fingerprint and effectively impossible to go backward from the fingerprint to the seed. That is the property that lets a site lock in its secret before you play without showing it to you. If you want the full picture of how that commit-then-reveal step works, the what is provably fair guide walks through it, and the server seed page covers the value being hashed.
SHA-256 and SHA-512 are two members of the SHA-2 family, published by NIST in FIPS 180-4. They do the same job. The main visible difference is the size of the fingerprint they produce. SHA-256 produces 256 bits, which is written as 64 hexadecimal characters. SHA-512 produces 512 bits, written as 128 characters. A hexadecimal character encodes 4 bits, so 256 divided by 4 is 64, and 512 divided by 4 is 128. That is the whole reason one commitment line looks twice as long as the other.
Here is what each looks like in practice, using the same short input so you can see only the length change:
input: "hello"
SHA-256 (64 hex chars):
2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
SHA-512 (128 hex chars):
9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca7
2323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043
Same input, two fingerprints. Change one letter of the input and both outputs change completely and unpredictably, which is exactly the behavior a fairness commitment relies on.
SHA-256 vs SHA-512 at a glance
| Property | SHA-256 | SHA-512 |
|---|---|---|
| Output length | 256 bits | 512 bits |
| Hexadecimal characters | 64 | 128 |
| Family | SHA-2, NIST FIPS 180-4 | SHA-2, NIST FIPS 180-4 |
| Direction | One-way, not reversible | One-way, not reversible |
| Where you see it on a box site | Ripster, HypeDrop, CSGORoll, Cases.gg, Skin.club, LuxDrop, CSGOEmpire | PackDraw, JemLit |
| Does it change whether you can verify? | No | No |
The last row is the one that matters most for a player. Whichever hash a site uses for its commitment, the verification you run afterward is the same: recompute the outcome from the revealed seed and confirm the fingerprint matches. The length of the fingerprint does not make one result more trustworthy than the other.
Where you see each one on a box site
Different platforms made different choices, and both are common in this space. Among the sites this tool covers, SHA-256 is used for the commitment on Ripster, HypeDrop, CSGORoll, Cases.gg, Skin.club, LuxDrop, and CSGOEmpire. SHA-512 is used for the commitment on PackDraw and JemLit. So if you rotate your seed on PackDraw and the revealed hash is a 128-character string, that is expected. On CSGORoll, the same panel shows a 64-character string. Neither is a sign of a better or worse site. It is just a design choice the operator made.
There is a second place hashing shows up, and it is worth separating from the commitment. The commitment hash proves the server seed was fixed in advance. A different step turns your three inputs, the server seed, your client seed, and the play count, into the actual roll. Many sites do that with a keyed hash called HMAC, and they can key it with either SHA-256 or SHA-512 depending on the platform. The HMAC explained page covers that keyed step in detail. The takeaway is that a site might commit with one hash and compute the roll with the keyed version of the other, and that is normal. What you verify is the end-to-end result, not the name of the hash.
Why do some box sites use SHA-512?
There is no single reason, and no rule in provably fair that forces one choice over the other. A site can build a sound, verifiable commitment with either hash, so the pick usually comes down to the operator's own engineering preferences rather than anything about fairness. Some teams reach for SHA-512 because it produces a longer output and feels like a bigger safety margin. Others stay on SHA-256 because it is the more common default across web software and has broad hardware and library support. A few sites use one hash for the commitment and the keyed HMAC version of the other to compute the roll, simply because that is how their code was written.
None of these choices tells you anything about how honest the site is. A 128-character commitment is not proof of a more careful operator, and a 64-character one is not a warning sign. The only thing the choice affects is the length of the string you copy when you go to verify. Read the hash for what it is, a fixed fingerprint of a secret the site locked in before you played, and let the recomputation, not the digit count, decide whether the result holds up.
Is one more secure than the other?
For the box-fairness use case, this question matters less than the search results make it sound. Both SHA-256 and SHA-512 are considered secure and neither has a known practical break. SHA-512 produces a longer output, which gives it a larger theoretical security margin, but SHA-256's margin is already far beyond anything current or foreseeable hardware can attack. For a completed case-opening result, you are not trying to break the hash at all. You are recomputing a value the site already revealed and checking it lines up. A longer or shorter fingerprint does not change whether that recomputation matches.
The one honest caution is unrelated to which hash is used: a fairness check confirms the math, not the business behind it. That distinction is covered in the scope note below.
How to check either one yourself
You do not need to know which hash a site uses before you start. The verifier below detects the platform's scheme, recomputes the outcome from the seeds you paste, and confirms the revealed server seed matches the fingerprint the site showed you first. If the site committed with SHA-256, it checks a 64-character hash. If the site committed with SHA-512, it checks a 128-character one. Everything runs on your own device, and nothing you paste is sent anywhere.
- Before you play, copy the hashed server seed the site shows you. This is the commitment, either 64 or 128 characters.
- Note your client seed and the play count for the pull you want to check.
- After you rotate seeds, copy the revealed server seed.
- Paste all of it into the verifier. It recomputes the outcome and confirms the revealed seed hashes back to the commitment.
If both line up, the result was fixed before you played and was not changed afterward, whichever hash length the site used.
Step 1Where did you play?
Using Ripster box / upgrade: HMAC-SHA256 over clientSeed:noncedetails
HMAC-SHA256 keyed with the server seed over clientSeed:nonce. The first 8 hex characters become a 32-bit integer, divided by 2^32 and multiplied by 100 for a roll in [0, 100). Items are sorted by item ID and selected by cumulative probability: the first item whose cumulative probability is at least the roll wins.
Where to find your numbers on Ripster.gg:
- Before rolling, copy the Server Seed Hash from the Provably Fair modal (also recorded per roll in Account History).
- After the roll, open the Provably Fair modal to copy the Server Seed, Client Seed and Nonce.
- Change your Client Seed anytime in Account Settings; doing so reveals the current Server Seed so all past rolls become verifiable.
Source: Ripster.gg's own fairness page
Step 2Paste your numbers
Runs entirely on your device via your browser's built-in cryptography. Don't take our word for it: open DevTools → Network, click the button, and watch: zero requests.
Runs entirely in your browser. Nothing you paste is sent anywhere.
The short version
SHA-256 and SHA-512 are two hashes from the same SHA-2 family. SHA-256 shows up as 64 hexadecimal characters and SHA-512 as 128, and that length is the only difference you will notice on a fairness page. Some box sites commit with one, some with the other, and a few use the keyed HMAC version of either to compute the roll. None of that changes what you are able to check. A committed seed that recomputes to the same fingerprint is a verified result, no matter which hash produced the fingerprint.