In a play-by-post game that requires a player to commit to a secret decision and later reveal that decision publicly, how can a player certify that they did so honestly without just relying on good faith? Consider the following example.

1. Alice commits to a decision, like pre-programming an action she will take. An onlooker might notice she's doing something but they wouldn't know the particulars.


2. Though Bob doesn't know exactly what Alice is up to, he commits to a decision in response to that, like reacting to stop her. Resolving his decision will depend on resolving her decision.


3. Alice has to reveal what her committed decision was after the fact in order to resolve it at this point along with Bob's reaction to it. If she's being honest or has a way to certify what her decision was, this is fine. If she is able to lie, she could change her decision retroactively.

Are there common tools, techniques, or conventions to support this? At a table, Alice could simply write her decision in a folded note card and reveal it later; or in a board game, she could play her action card face down and reveal it later. These common table conventions don't translate well to online play. So, how can Alice certify her secret decision to be revealed on a delay?

Assume the game has a GM but that the GM is also a player in need of certifying their decisions and can't act as a proxy for the other players.

Have Alice generate and publish an SHA-256 hash of her action.

SHA-256 is a computationally-secure (to reasonable approximation) algorithm that converts a given string into an unintelligible hexadecimal hash. There are online implementations that will compute SHA256 for you, for instance, here.

The idea is this:

1. Alice decides her action - say, "I cast Fireball at Bob"


2. Alice privately records that exact text
   


3. Alice enters that text into an SHA256 generator, producing a meaningless jumble of characters - A0FC4543FDBA266006F1F9FA818183710A8C5CA80613DA109B8A9DBA194DEC4E


4. Alice publicly announces "I've planned an action; its SHA-256 is A0FC4543FDBA266006F1F9FA818183710A8C5CA80613DA109B8A9DBA194DEC4E"

Now, Bob cannot tell what Alice has planned because the SHA-256 is not reversible; there's no way to get from the hash back to the action.

Later, when Alice reveals her plan, she gives the exact text she prepared earlier. If Bob doesn't trust her, he can simply repeat the SHA-256 encryption, and verify that the signatures match.

If Alice suspects that Bob may guess her action, then she can make things harder by adding an extra, irrelevant component to the action before computing the SHA-256. For instance, if Alice records, signs, and later reveals "I cast Fireball at Bob (pistachio)", then Bob would not be able to guess and verify the action without also guessing the extra "(pistachio)". This is known as using a "salt".

Send the decisions to a trusted third party.

When the time comes to reveal the action, the third party will then do so.

This has the advantage of being simple and doesn't require any technological know-how.

Use a communication system like facebook that allows you to set up visibility on each post.

Post a publicly visible post saying

Alice glances at her spell book then gestures, ready to begin casting a spell.

Post a private post saying

If X happens Alice will cast fireball at Y

If the trigger happens change the privacy of the post to public.

The timestamp and edit history should be able to show that the post has not been modified other than to change the visibility.

If you have a DM or similar in the game then you could also give them access to the private posts for their information.

An alternative to hash commitment that requires less technical knowhow: do what scientists used to do to establish priority for an idea until they were ready to publish. Instead of a SHA, publish a signature that is easily derived from the message by a human but can't be easily reversed.

One simple "signature" is just to show how many times each letter appears in the message, but not their order. Then when it's time to reveal, it's easy to verify. So Alice can sign the message

I betray Bob

as

ABBBEIORTY

One obvious problem is that for such a short, straightforward message, Bob can probably guess what is meant: there are a lot of Bs and one O, so it's probably about him. He can also rule out some possibilities he's worried about: the message clearly can't include fireball, because there's no F; but it could include betray.

Alice can prevent this by speaking somewhat more cryptically or using a few more words than necessary. If Alice publishes

AAABDDDDEEEEEFGGGHHHHHHIIIIIILLLLMMNOOOOOORRRRRSSTTTTTTTUUUWW

it's hard to guess that she means

Though allied with Robert, I grow tired of him and sell him out to the guards.

Just for fun, note that this message does leave open the possibility of a fireball, in case Alice thinks that's something Bob would want to rule out.

Trust

This one isn't always appropriate - but if you play with a constant group of friends, then simply trusting that they are being honest is the way I usually play games. This works for me, because I don't generally play with randoms or at events outside of home.

Obviously this won't always work - not everyone has the required integrity to resist the urge to cheat. But if you're playing a longer campaign with a consistent group, you'll learn pretty quickly using this method whether it's actually viable.

If not, then the other methods mentioned above are steller. However, as far as simplicity and ease to implement is concerned, this is by far the easiest.