[Guest]

Crack the Code 11 - Ho Ho Ho, Mwuhahahaa!

WARNING:

This is different from the preceding games, in that it is nastier.

I've deliberately designed this code so as not to leave any obvious clues. There are clues, but they are not obvious, and may be misleading. Don't say I didn't warn you. It's not devised in an unsporting way, but as an experiment, I've pulled no punches and just tried to make a really hard-to-solve algorithm. Whoever solves this one is truly a master hacker.

That being the case, I've changed the rules slightly so as to do 5 clues at a time.

Game Description

One player plays the Evil Mastermind (that's me) who nukes the states of the USA 5 at a time, the other players play Hackers who seek to stop the Evil Mastermind. Anyone can join in at any time as a Hacker.

The Evil Mastermind plays by posting commands which activate missile strikes. Each command has a unique password, which is derived from the command by a hashing algorithm. The Evil Mastermind devises a different algorithm at the start of each game, and posts the passwords along with the commands. The Evil Mastermind wins the game if he is able to post all the 50 commands.

The Hackers will see the commands and passwords in the thread and from this they should try to deduce the hashing algorithm. The Hacker who does this first, and correctly figures out the password to the command "ABORT", stops the Evil Mastermind and wins the game.

Game Restrictions

Since hashing algorithms can be exceedingly difficult to crack, there are restrictions placed on the kind of algorithm that the Evil Mastermind is allowed to use:

1) What it is

The Evil Mastermind must be able to derive an alphanumeric password of fixed length from any word (password length 8 characters or less, you choose). It doesn't have to be a cipher in the sense that it can be decrypted to the original word, indeed the fixed length makes that impossible.

2) Simplicity

You must be able to do it in your head, with no external aids, in 40 seconds or less. You may look at the word you are hashing but you should not have to look at the previous letters of the password, since real-life passwords are generally shown as ***** as you type (although you may use previous letters as far as your memory can handle it). It's up to you to ensure that you can do all this. A really classy algorithm is one which fulfils this condition better (quick and easy to perform, in other words).

3) No memory feats

Although it is quite possible to hold an alphabetic substitution table in your head, and apply it quickly, I'll rule this out because in conjunction with other techniques it's too difficult to crack. Any technique that requires a large amount of information to be memorised in advance is not allowed. Caesar ciphers with a large shift may fall into that category.

4) Consistency

This is a matter of good sportsmanship. For example, since "ABORT" is the target word, you can't have a rule that comes into play only when the sequence "BOR" occurs. All rules should be general enough that they come into play in either one third of the clues posted at any given time, or 10 clues posted. The algorithm should not be geared toward the specific commands used in this game, but should work on any word.

Game Play

The Evil Mastermind posts 5 commands at a time, with their passwords. The interval for doing this is undefined, no point in imposing restrictions. The Evil Mastermind chooses the commands. Hackers can also request specific states as the Evil Mastermind next targets, if they hope to get more information about the algorithm through these states' passwords.

Each Hacker may make one guess at the password for "ABORT" each time the Evil Mastermind posts commands. If someone makes multiple guesses in between clues, only the first one counts, but if they make a mistake and correct it, the Evil Mastermind can accept the correction. More than one Hacker can make guesses in between Evil Masterminds attacks and the Evil Mastermind is forced to acknowledge and respond to all the input (limited to 1 per Hacker).

There is no need for spoilers when guessing the password, although please use spoilers if you reveal the algorithm. Hackers can cooperate in the thread and share what they figured out so far with the rest of the community, but only if they use spoilers!.

The first Hacker to get the password for "ABORT" wins. The Hacker that stops the Evil Mastermind can choose to share his credit with other Hackers if he acknowledges being helped by others' findings.

Alternatively if you've cracked the algorithm you can just use it to blow up more states if you're that way inclined (**per original Evil Mastermind's rules!) instead of posting the "ABORT" command. A successful input of a batch of 3 states (which were not played before) grants you the title of Evil Mastermind Apprentice. The game continues until either the states are finished or a Hacker inputs the "ABORT" command.

Game Commands

There are 51 commands, these being the names of US states (used by the Evil Mastermind to nuke each state), plus the word "ABORT" (used by Hackers to stop the Evil Mastermind). All commands and passwords are UPPERCASE.

ABORT

ALABAMA

ALASKA

ARIZONA

ARKANSAS

CALIFORNIA

COLORADO

CONNECTICUT

DELAWARE

FLORIDA

GEORGIA

HAWAII

IDAHO

ILLINOIS

INDIANA

IOWA

KANSAS

KENTUCKY

LOUISIANA

MAINE

MARYLAND

MASSACHUSETTS

MICHIGAN

MINNESOTA

MISSISSIPPI

MISSOURI

MONTANA

NEBRASKA

NEVADA

NEWHAMPSHIRE

NEWJERSEY

NEWMEXICO

NEWYORK

NORTHCAROLINA

NORTHDAKOTA

OHIO

OKLAHOMA

OREGON

PENNSYLVANIA

RHODEISLAND

SOUTHCAROLINA

SOUTHDAKOTA

TENNESSEE

TEXAS

UTAH

VERMONT

VIRGINIA

WASHINGTON

WESTVIRGINIA

WISCONSIN

WYOMING

Game History

This game thread continues the tradition of the other games, but it is not directly related to any of them.

Each challenge is a new independent algorithm. However, you can read and try for yourself any of the previous challenges:

- Host: octopuppy - Winner: fabpig - No. of states destroyed: 25

- Host: octopuppy - Winner: araver - No. of states destroyed: 39

- Host: araver - Winner: octopuppy - No. of states destroyed: 21

- Host: dawh - Winner: octopuppy - No. of states destroyed: 3

- Host: octopuppy - Winner: Vineetrika / araver - No. of states destroyed: 39

- Host: Vineetrika - Winner: octopuppy - No. of states destroyed: 30

- Host: araver - Winner: octopuppy - No. of states destroyed: 45

- Host: octopuppy - Winner: Vineetrika - No. of states destroyed: 49

- Host: araver - Winner: octopuppy - No. of states destroyed: 27

- Host araver - Winner: octopuppy - No. of states destroyed: 21

[Guest]

Let the destruction begin.

COLORADO

PCBQRTES

MARYLAND

TMBNMCEM

NEWYORK

YPRQQLNM

RHODEISLAND

RQBBNMCE

WISCONSIN

UPNMQTLM

[Guest]

ALASKA

VBLKCDEV

HAWAII

BKIDMZNO

KENTUCKY

PVCBWLYX

NEVADA

BNMCHFOI

VERMONT

TPNMQUVU

[Guest]

CALIFORNIA

XQRBLKCL

DELAWARE

FDCGHYSI

MISSOURI

UPWLUSPU

TEXAS

WBSRCUHU

WASHINGTON

UJNMKHTS

That's all for today!

[Guest]

ALABAMA

BCDOEFGQ

GEORGIA

FQHLINVJ

IOWA

JQDYMNUH

NEWJERSEY

YFRQGTHI

NORTHDAKOTA

TIDCFOBN

[araver]

nothing so far. Let's get the usual suspects in, just in case: OHIO, UTAH, KANSAS, ARKANSAS, SOUTHDAKOTA.

This 5-at-a-time puts some real pressure on top of normal pressure from the holidays.

[Guest]

nothing so far. Let's get the usual suspects in, just in case: OHIO, UTAH, KANSAS, ARKANSAS, SOUTHDAKOTA.

This 5-at-a-time puts some real pressure on top of normal pressure from the holidays.

Hopefully this will help your stress levels; I'll be absent from 23rd Dec to 7th Jan, so if this isn't solved in the meantime I'll leave it at about 40 states over Christmas.

There just didn't seem much point in doing 3 at a time since I'm pretty sure you'll need a lot of states to get to a solution.

OHIO

JQILJSTU

UTAH

KBHGCXJU

ARKANSAS

SKJPPJBR

KANSAS

PBSRCLDE

SOUTHDAKOTA

PWIDCFXF

[Guest]

ILLINOIS

MLKJPJJL

MISSISSIPPI

UJSRKTLM

OREGON

SPNMQRIO

WESTVIRGINIA

UWJRQKHL

WYOMING

WVEJNMKH

[Guest]

CONNECTICUT

PFCBGULV

NEWHAMPSHIRE

YBMLCQSR

SOUTHCAROLINA

PWICBFXE

TENNESSEE

PFSRGTHI

VIRGINIA

TJNMKLMQ

Only 15 left now!

[Guest]

ARIZONA

BCLPETOW

FLORIDA

FEBFECMR

IDAHO

PKDMTUPI

NEWMEXICO

YFXWGLPX

NORTHCAROLINA

TICBFOBN

Merry Christmas to you all, and a Happy New Year.

See you on the 7th!

[Guest]

Whoops, I've been a bit slow to get back to you there. Well, let's finish this:

LOUISIANA

PWTLENGP

MASSACHUSETTS

UBCBCIXV

MICHIGAN

EJGFKDMJ

MONTANA

PBNMCDPE

OKLAHOMA

LLKIBQMD

For anyone looking at this and wondering if there is any point in trying, don't be put off. In my opinion it is definitely solvable. Also definitely harder than previous CTCs, but there are ways to gain insight into what is going on here. It depends on making the right observations of course, which is easy for me to say since I'm seeing it from a different perspective. But those observations can be made.

I'll give it a couple of days before the last five. Last chance to stop the destruction!

[araver]

@Octopuppy - Just wanted you to know that some of us are still playing this (with some moderate progress). But seeing we only have 1 shot of this, we're probably not going to try unless absolutely sure. I still don't have an ABORT try I'm completely satisfied with, but I may have one in a couple of hours/days

I've been having some success deriving some kind of a rule/piece of algorithm by looking at:

NORTHDAKOTA

NORTHCAROLINA

VIRGINIA

MARYLAND

VERMONT

First password char comes from the third character in the command ®.

Moving left / right according to the difference between password char and command char.

E.g. for R in the command you get T in the password. T-R=2. Move two to the right in the command and you get the 5th character of the command. Write 5th character -1 in the password and move one place right again (6th character).

Encountering vowels seems to stop the counter and/or change the direction of parsing the command. Otherwise jump coordinates seem to get increased/decreased by one each time you compute a password char.

Edited January 24, 2011 by araver

[araver]

I can't seem to get this, so I decided to post my results, hopefully someone has a better idea.

There is an initial jump I can't seem to understand. Denote n the initial selected letter / jump.

Then you add (n-1) to the letter you jumped to, and move n-1 spaces to the right (when you pass the end of the word, you start at the beginning so last and first letter are linked).

For each character, you jump X positions left or right from your current position in the command and add (or subtract) X from the letter you arrive at. Special rules dictate how X changes each jump:

- it usually decreases / increases by 1

- arriving at a vowel seems to change the direction of the increment.

- Special rule if jump is negative and you arrive at a vowel: e.g if jump=-1 and you arrive at A,E,I,O,U then jump=2 otherwise jump=-2

- Unknown rule: if jump is -3 and you arrive at a vowel it changes to 1. if jump is -2 and you arrive at a vowel it changes to 3.

- some other rules (possibly affected by passing the end of the word) make some weird jump changes.

I can't seem to unify the pseudo-rules above.

Below is a table of commands / starting position (not sure of all of those) / vector of jumps for the 8 characters in the password (pretty sure of all of them except 3 or 4 of them which depend on the starting position)

COMMAND - Start letter (position) [jump for password char 1, jump for password char 2, etc]

------------------------

IOWA - Start I(1) [1,2,3,2,4,5,6,7]

FLORIDA - Start F(1) [0,-1,1,0,-1,2,1,3]

RHODEISLAND - Start R(1) [0,-1,-2,1,0,-1,2,1]

WYOMING - Start W(1) [0,-1,-2,1,0,-1,2,1]

ARKANSAS - Start R(2) [1,0,-1,-2,-3,-4,1,0]

GEORGIA - Start E(2) [1,2,1,3,4,5,4,3]

ILLINOIS - Start L(2) [1,0,-1,-2,-3,-4,1,0]

LOUISIANA - Start O(2) [1,2,1,3,4,5,6,7]

OKLAHOMA - Start K(2) [1,0,-1,-2,1,2,1,3]

SOUTHDAKOTA - Start O(2) [1,2,1,0,-1,-2,3,2]

SOUTHCAROLINA - Start O(2) [1,2,1,0,-1,-2,3,2]

CONNECTICUT - Start N(3) [2,1,0,-1,2,1,3,2]

KANSAS - Start N(3) [2,1,0,-1,2,1,3,4]

KENTUCKY - Start N(3) [2,1,0,-1,2,1,0,-1]

MARYLAND - Start R(3) [2,1,1,0,-1,2,1,0]

MASSACHUSETTS - Start S(3) [2,1,0,-1,2,1,3,2]

MICHIGAN - Start C(3) [2,1,0,-1,2,3,4,3]

MISSOURI - Start S(3) [2,1,2,3,2,4,3,2]

MISSISSIPPI - Start S(3) [2,1,0,-1,2,1,3,4]

MONTANA - Start N(3) [2,1,0,-1,2,3,2,4]

NEWYORK - Start W(3) [2,1,0,-1,2,1,0,-1]

NEWJERSEY - Start W(3) [2,1,0,-1,2,1,3,4]

NEWMEXICO - Start W(3) [2,1,0,-1,2,3,2,1]

NEWHAMPSHIRE - Start W(3) [2,1,0,-1,2,1,0,-1]

NORTHDAKOTA - Start R(3) [2,1,0,-1,-2,-3,1,0]

NORTHCAROLINA - Start R(3) [2,1,0,-1,-2,-3,1,0]

OHIO - Start I(3) [1,2,1,3,2,4,5,6]

TENNESSEE - Start N(3) [2,1,0,-1,2,1,3,4]

VERMONT - Start R(3) [2,1,0,-1,2,1,0,-1]

VIRGINIA - Start R(3) [2,1,0,-1,2,3,4,3]

WASHINGTON - Start S(3) [2,1,0,-1,2,1,0,-1]

WESTVIRGINIA - Start S(3) [2,1,1,0,-1,2,-1,-2]

WISCONSIN - Start S(3) [2,1,0,-1,2,1,3,4]

ALASKA - Start S(4) [3,1,0,-1,2,3,4,3]

HAWAII - Start A(4) [1,2,1,3,4,3,5,6]

UTAH - Start H(4) [3,1,0,-1,2,3,2,1]

IDAHO - Start O(5) [1,2,3,4,5,6,7,8]

OREGON - Start O(5) [4,1,0,-1,2,3,2,1]

TEXAS - Start S(5) [4,1,0,-1,2,1,3,2]

NEVADA - Start A(6) [1,0,-1,2,3,2,1,4]

ALABAMA - Start A(7) [1,2,3,2,4,5,6,5]

ARIZONA - Start A(7) [1,2,3,2,4,5,6,5]

CALIFORNIA - Start R(7) [6,5,4,1,0,-1,2,3]

COLORADO - Start O(8) [1,0,-1,2,3,2,1,4]

DELAWARE - Start E(8) [1,0,-1,2,3,2,1,4]

Going to NE_W_HAMPSHIRE

Found char: W

Computing next jump!

Jump = 2

Adding 2 to W => Password char: Y

Next position is A

------------------------------------------------------------

Going to NEWH_A_MPSHIRE

Found char: A

Computing next jump!

Jump = 1

Adding 1 to A => Password char: B

Next position is M

------------------------------------------------------------

Going to NEWHA_M_PSHIRE

Found char: M

Computing next jump!

Jump = 0

Adding 0 to M => Password char: M

Next position is M

------------------------------------------------------------

Going to NEWHA_M_PSHIRE

Found char: M

Computing next jump!

Jump = -1

Adding -1 to M => Password char: L

Next position is A

------------------------------------------------------------

Going to NEWH_A_MPSHIRE

Found char: A

Special RULE #1 in place!

Computing next jump!

Jump = 2

Adding 2 to A => Password char: C

Next position is P

------------------------------------------------------------

Going to NEWHAM_P_SHIRE

Found char: P

Computing next jump!

Jump = 1

Adding 1 to P => Password char: Q

Next position is S

------------------------------------------------------------

Going to NEWHAMP_S_HIRE

Found char: S

Computing next jump!

Jump = 0

Adding 0 to S => Password char: S

Next position is S

------------------------------------------------------------

Going to NEWHAMP_S_HIRE

Found char: S

Computing next jump!

Jump = -1

Adding -1 to S => Password char: R

Next position is P

------------------------------------------------------------

NEWHAMPSHIRE -> YBMLCQSR

NEWHAMPSHIRE - Start W(3) [2,1,0,-1,2,1,0,-1]

And my final shot-in-the-dark at ABORT:

BBACRCPR

Edited January 30, 2011 by araver

[Guest]

Sorry, I haven't been keeping up to date with Brainden so regularly. I'd assumed this had died and not noticed your answer...

And my final shot-in-the-dark at ABORT:

BBACRCPR

Not even close, although your algorithm is tantalisingly close. 2 missing pieces, neither of which is as complex as it seems. Since you've already done the hard part, all I can do is offer my encouragement to finish it off.

PS you got the start position wrong for OREGON

[araver]

2 missing pieces, neither of which is as complex as it seems. Since you've already done the hard part, all I can do is offer my encouragement to finish it off.

Hmmm, guess this means I can try again *sigh*. OK, will think about it.

[voider]

Humanoid (vague) analysis based on araver's lead:

All clues being equally chaotic, it seems like A E I O U might be 'different', and that consecutive or in-between vowels sometimes have no effect. The effect of vowels seems more complicated than a fixed combination of toggling offset's isz/dsz status and adding on the spot.

For spontaneous (unexplained) changes in offset it seems like adding odd numbers occurs a lot more than adding even numbers (at least in my notation).

All jumps seem to be positive-ended (from our natural POV).

Other analysis:

Following these rules naively (basically araver's observations)

-3 -> 1 when hitting vowel

-1 -> 2 when hitting vowel

-4 -> 1 when hitting vowel

-2 -> 3 when hitting vowel

I get this output:

I have used a very insufficient algorithm for guessing the starting position: 1 if non-vowel, 2 if vowel. The first position is 0.

If I plugged in araver's starting points I'd have more data on where the current algorithm is wrong.

If the first letter is correct, I've assumed it's the correct starting point. (I think this accounts for the outliers.)

The error output then indicates the first discrepancy between our guess and the correct password in the form:

<Letter landed on> <Position of this letter (starting at 0)> / <Length of command> <Projected offset> <Actual offset>

Projected offset is just this: e.g. 2 1 0 -1 -2; always assuming the offset is decremented.

Correct: ARKANSAS

Correct: ILLINOIS

Correct: KENTUCKY

Correct: NEWHAMPSHIRE

Correct: NEWYORK

Correct: NORTHCAROLINA

Correct: NORTHDAKOTA

Correct: VERMONT

Correct: WASHINGTON

Got 9 out of 45 correct

Wrong guesses for:

ALABAMA

ALASKA

ARIZONA

CALIFORNIA

COLORADO

CONNECTICUT

DELAWARE

FLORIDA

GEORGIA

HAWAII

IDAHO

IOWA

KANSAS

LOUISIANA

MARYLAND

MASSACHUSETTS

MICHIGAN

MISSISSIPPI

MISSOURI

MONTANA

NEVADA

NEWJERSEY

NEWMEXICO

OHIO

OKLAHOMA

OREGON

RHODEISLAND

SOUTHCAROLINA

SOUTHDAKOTA

TENNESSEE

TEXAS

UTAH

VIRGINIA

WESTVIRGINIA

WISCONSIN

WYOMING

Wrongness analysis ---------------

ALABAMA

Wrong starting point

ALASKA

Wrong starting point

ARIZONA

Wrong starting point

CALIFORNIA

Wrong starting point

COLORADO

Wrong starting point

CONNECTICUT

I 7/11 0 3

DELAWARE

Wrong starting point

FLORIDA

Wrong starting point

GEORGIA

Wrong starting point

HAWAII

Wrong starting point

IDAHO

Wrong starting point

IOWA

Wrong starting point

KANSAS

A 1/ 6 0 3

LOUISIANA

Wrong starting point

MARYLAND

A 5/ 8 0 1

MASSACHUSETTS

U 7/13 0 3

MICHIGAN

A 6/ 8 1 2

MISSISSIPPI

I 7/11 0 3

MISSOURI

U 5/ 8 0 2

MONTANA

A 6/ 7 1 2

NEVADA

Wrong starting point

NEWJERSEY

E 7/ 9 0 3

NEWMEXICO

I 6/ 9 1 2

OHIO

Wrong starting point

OKLAHOMA

A 7/ 8 3 -2

OREGON

E 2/ 6 0 11

RHODEISLAND

Wrong starting point

SOUTHCAROLINA

Wrong starting point

SOUTHDAKOTA

Wrong starting point

TENNESSEE

E 7/ 9 0 3

TEXAS

Wrong starting point

UTAH

Wrong starting point

VIRGINIA

I 6/ 8 1 2

WESTVIRGINIA

I 5/12 0 1

WISCONSIN

I 7/ 9 0 3

WYOMING

Wrong starting point

CONNETICUT I 7/11 0 3

KANSAS A 1/ 6 0 3

MARYLAND A 5/ 8 0 1

MASSACHUSETTS U 7/13 0 3

MICHIGAN A 6/ 8 1 2

MISSISSIPI I 7/11 0 3

MISSOURI U 5/ 8 0 2

MONTANA A 6/ 7 1 2

NEWJERSEY E 7/ 9 0 3

NEWMEXICO I 6/ 9 1 2

OKLAHOMA A 7/ 8 3 -2

OREGAN E 2/ 6 0 11

TENNESSEE E 7/ 9 0 3

VIRGINIA I 6/ 8 1 2

WESTVIRGINIA I 5/12 0 1

WISCONSIN I 7/ 9 0 3

Obviously stopping at the first discrepancy is just a hopeful snapshot of a representative discrepancy in the algorithm. This, the assumption of the offset being decremented by default, and ignoring the rest of the actual offset vector could mean that there are no clues in this data (the cost of assuming that first vowels' effects are mostly independent of other vowels' effects and positions.)

Edited November 4, 2011 by voider