Yeah, I’m dropping the 64 code for now I can’t make any sense of it, I was searching on the wiki for more clues, and found this:
https://thepizzaisalie.wikia.com/wiki/Storyline#comm-2237
Seems that stormseeker disagreed with the story. It seems a pretty reasonable story to be fair, maybe he wanted something different, like inventing things to fill the gaps.
AngelSG, did you try the “congratulationsyouwonthePIZZA” as a potential phrase? I mean, so far we have not seen any use of the phrase, so it very well might be possible.
Yes, I tried it with SECOM and with VIC, nothing but gibberish. That phrase could be the key to something, but if stormseeker draw inspiration from torment by greegecko, I’m afraid it may be a dead end. In that ARG there were some paths that lead you to something that seemed to be the end, but were just red herrings. Or maybe the ARG was supposed to end there, but stormseeker decided to expand it.
I was thinking though, there is a resemblance between the name HALOS and the AI from 2001, HAL. After all, weren’t there lyrics of that Daisy song on one of the monitors? Is it possible that we might have to search for clues in 2001 A Space Odyssey?
Actually I had alredy checked the song on the VIC cipher. But I don’t think that watching the movie is necessary. Well, if you didn’t watch it do it, it is quite a trip, but ARGwise, it’s probably just a refference like the show bugs.
Edit: Opening the image files in hex I found this 456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz and this 56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz inside 180px-Lies.jpg, is that normal? Also, inside grilledpizza.jpg there is an url https://www.iec.ch, it’s the international electrotechnical comission. I don’t know anything about image files, so maybe this is just regular stuff. I checked both of them with a stenography detector and it didn’t detect anything.
Edit 2: On the 752 message “{Primary Servers Overloaded}” is the only part that goes between {} instead of []. That only happens with that, on the IRC clue 1 with {Interrupts}, and on the Tempus Omnia revelant several times. It may be worth to add it to the possible passwords list.
This is officially mind-blowingly frustrating.
EDIT: So, at this point I’ve run quite a few tests on this thing, and I don’t think it’s a “traditional” cipher. I have no freaking idea what else it could be, but that’s where I am with it. There are just too many repeats, and the only numbers used are: 0, 1, 2, 6, 7, 8, 9
The other frustrating thing is we can’t know for sure that this is the way it was supposed to be decoded. Furthermore, it could have simply been Storm typing random things. It could mean absolutely nothing.
Completely agree with you, ciphers or codes do not produce ciphertexts with more repepetitions that the ones founded on the plaintext, so, it’s not a ciphertext; it’s a custom cipher that uses base 7, or/and the plaintext has tons of repetitions. I’m gonna keep trying with the 752 since it should be solvabe without the 64 code. The 64 maybe it’s just a red herring that is there to draw attention from the real clue. Or maybe the length is the clue, it is 256 bits.
Edit: I think this has not been tried, “PASSCODE INPUT FOR SITE ACTIVATION REQUIRED”, it says passcode instead of password, maybe seek code out meant to look at this instead of searching for user code? so the passcode would be the input for site activation, drhorn1001085139140914, or maybe thepizzaisaliedrhorn1001085139140914. I’m just not going to try by hand till I have the linux distro, so I can use the shell script that other user posted, the list of possible passwords I have it’s too big right now.
Edit: Looking at the exact definition of passcode, “…[Instead of password]The term passcode is sometimes used when the secret information is purely numeric[eg the PIN on a mobile phone]” 1001085139140914 is yet another option…
Isn’t it possible that our 64-code is our passcode? Storm did mention in his message to me that the hex code is most likely a holding puzzle to provide more time for other things to progress before returning attention to the ARG–maybe this is the piece we’ve been waiting on.
If that were the case then stormseeker had everyone trying to solve something that cannot be solved, and that is not cool. He could have told the people that the ARG would resume once he finished whatever he’s doing (Xen maybe?). I think what he meant was that the puzzle is extremely difficult, or riddle with red herrings so it takes more time to solve than the previous puzzles. The fact that he wrote Tempus Omnia Revelant about a year ago means that he probably did not anticipate that the puzzle would hold people for so long. But right now how many people is actively trying to solve this? four, five? And I don’t know about you or the rest of the people, but I learned everything I know about cryptography since january, so you might as well not take me into the account. So, more difficult puzzle+less manhours=very long time to solve 
Nevertheless, I’m going to try the code as the key for AES 256… with either iv 0 or iv ABORT in hex. Maybe you’re right and this was really something that could not be solved. If it doesn’t work I’m going to write down previous tries from when stormseeker said that someboy was already close, but, then again, if this was unsolvable, and he wanted people to keep trying the best way probably was to give hope about solving it.
Edit: Nothing, I tried with every mode for AES-256 with both iv 0 and iv ABORT in hex.
I’ve printed out a bunch of different pages and I’m looking at all the data at once. One thing I noticed is that there are some of the same symbols in the repeat of the “Konami Code” message from the Tempus page on the Wiki.
One part: “+&&#//#//”
If we convert that as we have done with the new message, it’s: “+87873//3//”
Can’t be sure that the # should be converted at all, however, as there are quite a few of them. Also, I noted something about the Tempus page–it means “time reveals all”; could this be a hint that the hex code is related to time? I’m not sure how that would work, but just a thought.
EDIT: Perhaps the “time” could be referencing the half-life of niobium. I mean, the game is called Half-Life, and we do have a list of niobium isotopes on the Tempus page that includes a column for half-life. This column has quite a few numbers and whatnot in it. I’m going through right now to see if I can make sense of anything. The fact that Storm hinted that it might not be encryption related makes me think he may have made it look like a hex code just to throw us off.
EDIT 2: Something else I’ve been wondering about. We know that our password for the site was: “1001085139140914”. However, do we know why it was these numbers? Kind of like Angel’s idea, it could be a passcode for input; on the other hand, perhaps it is encrypted itself. I doubt Storm just threw out random numbers–I doubt that’s the way he thinks. Therefore, these numbers must come into play at some point, in one way or another.
I looked into that, but after getting a buch of numbers I didn’t know what to do with them.
Tempus omnia revelant it’s Time will reveal all. I thought of the date, 12.12.12, again didn’t know what to do with it. The “1001085139140914” might be relevant, maybe it’s necessary because it is the iv, the problem is that this became an epileptic tree long time ago, so there are tons of theories to check. After reading older posts, there was a message claiming that stormseeker said that someone was close, it’s on page 70 of the thread, the date is 23-01-13, that means that somebody was close long time ago. The theories were basicaly a symmetric encryption cipher and turn it into an image, which aparently it’s just noise. So, the only thing left is the symmetric ciphers.
What we do know, is that the clues must relete in some way, so searching in the Tempus Omnia Revelant and in the new message, we may find something.
Also, could you imagine that all this was just viral marketing for a pizza restaurant in London? Like the angel statue in the Simpsons?
https://www.yelp.co.uk/biz/752-pizza-london
Before anyone says anything, yeah, I know it’s unrelated, nevertheless I can’t help myself but find it funny 
[quote=“AngelSG”]
The theories were basicaly a symmetric encryption cipher and turn it into an image, which aparently it’s just noise.
[QUOTE]
Yeah, I tried the image thing a ton, but I didn’t get much. It could still be this however, depending on the method utilized.
I don’t think it’s an image, if you and other people tried it and it didn’t work it’s probably not that. After reading what storm sent you as 0418, my money is on AES-256, the password is probably something that can be found on the whiteboards or the messages. This has been tried before, but we could always expand the passwords. I’m burning the linux distro, tomorrow I will be set for password testing.
I have pretty much concluded at this point that we’re dealing with 3DES. The Lucifer cipher is directly connected to DES. Furthermore, we have things happening in groups of threes:
[b]In the image with red writing, the word “lies” is written three times–there may be a fourth, but it looks like something else.
The first “lies” is also underlined three times.
We have three instances of Satan/Lucifer being mentioned:
Other than that, I think it’s just a feeling. I found this page randomly tonight: It details how someone solved a hex code for a contest to win tickets. The first round of the code actually mentioned Lucifer, and the gentleman used DES to solve it. His hex code was extremely similar to ours.
Have you tried using a rot13 cipher?
That needs to be applied to text, even in the case that we used it with hex, it would just give gibberish since the entropy of the code is high and the entropy would not vary by doing rot13 or any other monoalphabetic substitution. Or you were talking about the code on the message that appeared on the wiki?
Yes, that might be true, the problem is that either storm lied to you through PM or on the clue, any of the two clues could be red herrings, but you’re right, there are inconsistencies and he probably lied at some point. I’ve installed a linux distro so I can test passwords fairly quickly thanks to the script posted by user Faed. I’m gonna start testing passwords and ciphers, right now the list has the passwords that user Faed wrote plus: LeptonOptronic… and variations using Laser instead of Lepton, accelerated, MK2… Divine Comedy, the code 1001085139140914 and congratulationsyouwonthePIZZA. If somebody has any more sugestions PM or post them.
If we are trying numbers as passwords, then maybe we should also try their ‘shifted’ variants:
‘1001085139140914’ -> ‘!))!)%!£(!$)(!$’ (uk layout)
‘1001085139140914’ -> '!))!)%!#(!$)(!$’ (us layout)
(the passwords in single quotes)
The half-life to τ (tau - the mean lifetime or the exponential time constant) conversion constant found on the c0a1x_labboard_am6 labboard:
‘1.442695040888963’ -> ‘!.$$"^(%)$)(^£’ or '!.$$@^(%)$)(^#’
With more digits (32 characters, enough for a 256-bit key):
‘1.442695040888963407359924681001’ -> ‘!.$$"^(%)$)(^£$)&£%(("$^!))!’ or '!.$$@^(%)$)(^#$)&#%((@$^!))!’
(perhaps also try replacing the ‘.’ with a ‘>’)
Since half-life, τ (tau) and λ (lambda) are all directly related and are all related to time (Time reveals all), I’m wondering if we should try converting the half-lives of the Niobium isotopes to their τ and λ equivalents and try them all as passwords. I would start with the 99Nb isotope since it’s in the middle of the list on the Tempus page:
t½ for 99Nb is 15.0s =>
τ: ‘21.64042561333445111039887021502’ -> ‘"!.^$)$"%^!£££$$%!!!)£(&)"!%)"’ or '@!.^$)$@%^!###$$%!!!)#(&)@!%)@’
λ: ‘0.046209812037329687294482141430’ -> ‘).)$^")(!")£&£"(^&"($$"!$!$£)’ or ').)$^@)(!@)#&#@(^&@($$@!$!$#)’
Formulas:
τ = t½ / ln(2)
λ = 1/τ => λ = ln(2) / t½
(where t½ = half-life)
It’s a long shot and there’s also the problem of how many digits to include, which is particularly important when using OpenSSL, since the whole password is used for deriving the key regardless of the key size of a given cipher.
I was joking about my lack of cryptographic knowledge.
Hah. I tried absolutely everything. Almost every 64-bit block cipher imaginable, almost all modes, tons of phrases in all thinkable capitalizations as both IV and password. I even tried stream ciphers. In my latest attempt I added many hash functions in case the password is hashed.
Either there’s still a password to be found or it’s simply not a modern cipher.
But since you are on linux, I assume you are familiar with gcc (I’m a win guy, but this should work anywhere).
Here’s the source code of my program (you need Crypto++), it should be way faster than scripts:
[code]#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
typedef unsigned char byte;
typedef unsigned int uint;
byte const Code[] {
0xB3, 0x2B, 0x00, 0x3A, 0x35, 0xBA, 0xDD, 0x66, 0x57, 0x7C, 0x24, 0xC1, 0x4F, 0xC9, 0x19, 0x06,
0x43, 0x46, 0xD1, 0x31, 0xA7, 0xC5, 0x4B, 0xB8, 0x2F, 0xFE, 0x03, 0xE0, 0x22, 0x61, 0x57, 0x77,
0x24, 0x79, 0x23, 0xDC, 0x21, 0xF6, 0x2C, 0xD4, 0x18, 0x2E, 0x91, 0xC3, 0xB2, 0x67, 0xB5, 0x45,
0xAB, 0xCA, 0xED, 0xAF, 0x02, 0x61, 0x51, 0x0D, 0x4E, 0xEA, 0x1E, 0x87, 0xCD, 0x33, 0xC7, 0xC7,
0x71, 0x31, 0x30, 0x9C, 0xC4, 0x28, 0x0E, 0xB4, 0x24, 0x3D, 0x11, 0x54, 0xF0, 0x44, 0xF9, 0xCF,
0x62, 0x96, 0xD9, 0xBF, 0xF7, 0x39, 0x7E, 0x43, 0x90, 0x98, 0x7F, 0xE6, 0x32, 0x03, 0xDA, 0x0D,
0xE4, 0x02, 0x78, 0xB3, 0xA5, 0x4F, 0x5D, 0xDC, 0x69, 0x75, 0xFA, 0x04, 0xF7, 0x49, 0x84, 0x9E,
0x1A, 0x62, 0x59, 0x5A, 0x9F, 0x63, 0x0B, 0x07, 0x95, 0x91, 0x3D, 0xE0, 0x15, 0x3E, 0x3A, 0xAC,
0x38, 0x8C, 0x45, 0xFB, 0x9D, 0x85, 0x0C, 0xFE, 0x91, 0x35, 0x41, 0xD6, 0xC0, 0x83, 0x98, 0xF2,
0xC8, 0x83, 0x32, 0xA8, 0x2F, 0xDF, 0x00, 0x28, 0x1D, 0x62, 0xFC, 0xDC, 0x4F, 0xE7, 0xE4, 0x6A,
0xE9, 0x0C, 0x51, 0xC5, 0xC8, 0x06, 0xB4, 0x11, 0x64, 0xE3, 0x3A, 0xB9, 0x2C, 0x96, 0x86, 0x2E,
0x06, 0x8B, 0x0C, 0x16, 0xC0, 0x99, 0x90, 0xB8, 0x38, 0x1A, 0x00, 0xDA, 0x79, 0x15, 0xB6, 0x7F,
0xE4, 0xA2, 0x0F, 0x59, 0x9B, 0x0F, 0x1B, 0x6D, 0x48, 0x19, 0x13, 0xC7, 0xB9, 0x53, 0x8C, 0xEE,
0x63, 0x91, 0x44, 0xF4, 0x15, 0x61, 0xBA, 0x92, 0xE4, 0xFE, 0x75, 0x1D, 0x1E, 0x24, 0x2C, 0xD8,
0x8F, 0x51, 0xD6, 0x95, 0x51, 0x98, 0x87, 0x13, 0x6A, 0x7C, 0x15, 0xAA, 0xBD, 0x7B, 0x40, 0x04,
0x49, 0x22, 0x01, 0x41, 0x30, 0xA9, 0x1F, 0x17, 0x0F, 0x66, 0xCC, 0xB3, 0xC1, 0x39, 0x46, 0x3A,
0x7E, 0x90, 0x9A, 0x37, 0xAA, 0x86, 0x3F, 0xB2, 0x78, 0x05, 0xFC, 0x97, 0x31, 0xC0, 0x9C, 0x8C,
0x79, 0x06, 0x7E, 0x79, 0x93, 0x0A, 0x40, 0x65, 0x46, 0xB2, 0x4C, 0x9A, 0x62, 0x9B, 0x26, 0xC2,
0xCE, 0x2A, 0x4B, 0xE4, 0x8F, 0x58, 0x9A, 0x37, 0x5F, 0xEB, 0x73, 0x1F, 0xC4, 0xAB, 0x22, 0x5C,
0x11, 0x84, 0x8C, 0xF8, 0x9E, 0x29, 0x1F, 0xB2, 0x71, 0x33, 0x97, 0x0C, 0x06, 0x36, 0x18, 0x47,
0x4A, 0x89, 0x28, 0x01, 0xED, 0xD6, 0x8F, 0x54, 0x69, 0x8C, 0x5E, 0x5B, 0x50, 0x67, 0x46, 0xF6,
0x76, 0x5A, 0x6F, 0x7F, 0x12, 0x25, 0xDE, 0xA4, 0xDA, 0x11, 0x40, 0xFE, 0xB6, 0x0F, 0x65, 0x07,
0x45, 0x24, 0x1C, 0x69, 0x36, 0x95, 0x88, 0x3D, 0xCB, 0x21, 0xE6, 0xFB, 0xFE, 0xFB, 0xB8, 0x5A,
0x29, 0x91, 0x94, 0x80, 0x36, 0xA5, 0x2B, 0x5D
};
#include “cryptopp/des.h”
#include “cryptopp/blowfish.h”
#include “cryptopp/idea.h”
#include “cryptopp/rc2.h”
#include “cryptopp/rc5.h”
#include “cryptopp/cast.h”
#include “cryptopp/safer.h”
#include “cryptopp/skipjack.h”
#include “cryptopp/tea.h”
#include “cryptopp/gost.h”
#include “cryptopp/shark.h”
#include “cryptopp/modes.h”
#include “cryptopp/panama.h”
#include “cryptopp/sosemanuk.h”
#include “cryptopp/salsa.h”
#include “cryptopp/arc4.h”
#include “cryptopp/seal.h”
#include “cryptopp/wake.h”
#include “cryptopp/md5.h”
#include “cryptopp/sha.h”
#include “cryptopp/sha3.h”
#include “cryptopp/tiger.h”
#include “cryptopp/whrlpool.h”
#include “cryptopp/ripemd.h”
using namespace CryptoPP;
vector<HashTransformation*> Hashes {
new MD5,
new SHA1,
new SHA224,
new SHA256,
new SHA384,
new SHA512,
new SHA3(0x1C),
new SHA3(0x20),
new SHA3(0x30),
new SHA3(0x40),
new Tiger,
new Whirlpool,
new RIPEMD128,
new RIPEMD160,
new RIPEMD256,
new RIPEMD320,
};
bool my_isalnum(char c)
{
return (c >= ‘0’ && c <= ‘9’) || (c >= ‘a’ && c <= ‘z’) || (c >= ‘A’ && c <= ‘Z’);
}
char my_tolower(char c)
{
return c >= ‘A’ && c <= ‘Z’ ? ‘a’ + (c - ‘A’) : c;
}
char my_toupper(char c)
{
return c >= ‘a’ && c <= ‘z’ ? ‘A’ + (c - ‘a’) : c;
}
string MC(string Text, uint c)
{
switch©
{
case 1:
for (size_t i = 0; i < Text.size(); ++i)
Text[i] = my_tolower(Text[i]);
break;
case 2:
if (!Text.empty())
Text[0] = my_toupper(Text[0]);
for (size_t i = 1; i < Text.size(); ++i)
Text[i] = my_tolower(Text[i]);
break;
case 3:
for (size_t i = 0; i < Text.size(); ++i)
Text[i] = my_toupper(Text[i]);
break;
}
return Text;
}
double ShannonEntropy(string String)
{
if (String.empty())
return 0;
size_t Counts[0x100] {};
for (size_t i = 0; i < String.size(); ++i)
++Counts[(byte)String[i]];
double result = 0;
for (size_t i = 0; i < 0x100; ++i)
{
double frequency = (double)Counts[i] / String.size();
if (frequency)
result -= frequency * log2(frequency);
}
return result;
}
vector<array<BlockCipher*, 2>> BlockCiphers {
{{new DES::Encryption, new DES: 
ecryption}},
{{new DES_EDE2::Encryption, new DES_EDE2: ecryption}},
{{new DES_EDE3::Encryption, new DES_EDE3: ecryption}},
{{new DES_XEX3::Encryption, new DES_XEX3: ecryption}},
{{new Blowfish::Encryption, new Blowfish: ecryption}},
{{new IDEA::Encryption, new IDEA: ecryption}},
{{new RC2::Encryption, new RC2: ecryption}},
{{new RC5::Encryption, new RC5: ecryption}},
{{new CAST128::Encryption, new CAST128: ecryption}},
{{new SAFER_K::Encryption, new SAFER_K: ecryption}},
{{new SAFER_SK::Encryption, new SAFER_SK: ecryption}},
{{new SKIPJACK::Encryption, new SKIPJACK: ecryption}},
{{new TEA::Encryption, new TEA: ecryption}},
{{new XTEA::Encryption, new XTEA: ecryption}},
{{new GOST::Encryption, new GOST: ecryption}},
{{new SHARK::Encryption, new SHARK: ecryption}},
};
vector<pair<array<CipherModeBase*, 2>, bool>> Modes {
{{{new ECB_Mode_ExternalCipher::Encryption, new ECB_Mode_ExternalCipher: ecryption}}, false},
{{{new CBC_Mode_ExternalCipher::Encryption, new CBC_Mode_ExternalCipher: ecryption}}, false},
{{{new CBC_CTS_Mode_ExternalCipher::Encryption, new CBC_CTS_Mode_ExternalCipher: ecryption}}, false},
{{{new CFB_Mode_ExternalCipher::Encryption, new CFB_Mode_ExternalCipher: ecryption}}, true},
{{{new OFB_Mode_ExternalCipher::Encryption, new OFB_Mode_ExternalCipher: ecryption}}, true},
{{{new CTR_Mode_ExternalCipher::Encryption, new CTR_Mode_ExternalCipher: ecryption}}, true},
};
vector<SymmetricCipher*> SymmetricCiphers {
new PanamaCipher<>::Encryption,
new Sosemanuk::Encryption,
new Salsa20::Encryption,
new XSalsa20::Encryption,
new ARC4::Encryption,
new SEAL<>::Encryption,
new WAKE_OFB<>::Encryption,
};
string Decrypt(BlockCipher& Cipher, string const& Key, string const& Code, CipherModeBase& Mode, string const& IV)
{
size_t blockSize = 8;
assert(Cipher.BlockSize() == blockSize);
assert(Code.size() % blockSize == 0);
size_t keySize = Cipher.GetValidKeyLength(Key.size());
byte* pKey = (byte*)alloca(keySize);
memset(pKey, 0, keySize);
copy_n(Key.begin(), min(Key.size(), keySize), pKey);
Cipher.SetKey(pKey, keySize);
byte* pIV = (byte*)alloca(blockSize);
memset(pIV, 0, blockSize);
copy_n(IV.begin(), min(IV.size(), blockSize), pIV);
Mode.SetCipherWithIV(Cipher, pIV);
string Output;
Output.resize(Code.size());
Mode.ProcessData((byte*)Output.data(), (byte const*)Code.data(), Code.size());
return Output;
}
string Decrypt(SymmetricCipher& Cipher, string const& Key, string const& Code, string const& IV)
{
size_t keySize = Cipher.GetValidKeyLength(Key.size());
byte* pKey = (byte*)alloca(keySize);
memset(pKey, 0, keySize);
copy_n(Key.begin(), min(Key.size(), keySize), pKey);
size_t IVSize = Cipher.IVSize();
byte* pIV = (byte*)alloca(IVSize);
memset(pIV, 0, IVSize);
copy_n(IV.begin(), min(IV.size(), IVSize), pIV);
if (IVSize)
Cipher.SetKeyWithIV(pKey, keySize, pIV);
else
Cipher.SetKey(pKey, keySize);
string Output;
Output.resize(Code.size());
Cipher.ProcessData((byte*)Output.data(), (byte const*)Code.data(), Code.size());
return Output;
}
int main(int argc, wchar_t* argv[])
{
vector Phrases {
“”,
“\x10\x01\x08\x51\x39\x14\x09\x14”,
“BenalohPaillier”,
“CohenPaillier”,
“JoshPascal”,
“GoldwasserMicali”,
“Goldwasser-Micali”,
“Benaloh”,
“Paillier”,
“HomomorphicEncryption”,
“HomomorphicCryptosystem”,
“HomomorphicCryptosystems”,
“Niobium”,
“Niobium5”,
“NiobiumV”,
“NiobiumFive”,
“NiobiumPentachloride”,
“Terminal”,
“Abortive”,
“ThEpIzZaIsaLiE”,
“Halos”,
“HalosProject”,
“HalosAI”,
“TempusOmniaRevelant”,
“BMRF”,
“BMRF.us”,
“terminal.bmrf.us”,
“DALsystems”,
“DALsystems.com”,
“1.192.12.156”,
“1.192.12.156:2828”
“BlackMesaResearchFacility”,
“congratulationsyouwonthePIZZA”,
“CongratulationsYouWonThePIZZA”,
“CongratulationsYouWonThePizza”,
“Pizza”,
“Pizzas”,
“GiordanoBruno”,
“Kryptos”,
“KryptosStatue”,
“BonAmi”,
“KONami”,
“KONamiCode”,
“KonamiCode”,
“DrHorn”,
“DrWelsh”,
“DrJWelsh”,
“DrMontero”,
“DrStone”,
“DrBottomley”,
“DrJunek”,
“DrForeman”,
“DrMarcel”,
“VoxpopulivoxDei”,
“VoxPopuliVoxDei”,
“YouShouldBringPizzas”,
“DantesInferno”,
“Dante’sInferno”,
“Nimrod”,
“SuperbusViaInscientae”,
“StarTrek”,
“GrilledPizza”,
“StormSeeker”,
“TheStormSeeker”,
“Anthony”,
“Biodome”,
“LaserOptronicLinearInducerCannon”,
“AcceleratedLeptonOptronicLinearityCannon”,
“AcceleratedLeptonOptronicLinearCannon”,
“LeptonOptronicLinearityCannon”,
“Accelerated”,
};
double lowest = 8;
for (size_t c = 0; c < 0x10; ++c)
{
cout << ((double)c / 0x10) << "\n";
for (auto Key : Phrases)
for (auto IV : Phrases)
for (auto pCipher : BlockCiphers)
for (auto pMode : Modes)
for (auto pHash : Hashes)
{
string Phrase = MC(Key, c % 4);
string Key;
Key.resize(pHash->DigestSize());
pHash->CalculateDigest((byte*)Key.data(), (byte const*)Phrase.data(), Phrase.size());
string Result = Decrypt(*pCipher[pMode.second ? 0 : 1], Key, string((char*)Code, sizeof(Code)), *pMode.first[1], MC(IV, c / 4));
double entropy = ShannonEntropy(Result);
if (entropy < lowest)
lowest = entropy;
if (entropy < 7)
{
cout << entropy << "\n";
cout << pCipher[0]->AlgorithmName() << ", " << MC(Phrase, c % 4) << ", " << pMode.first[0]->AlgorithmName() << ", " << MC(IV, c / 4) << ", " << pHash->AlgorithmName() << "\n";
cout << "\n";
}
}
}
for (size_t c = 0; c < 0x10; ++c)
for (auto Key : Phrases)
for (auto IV : Phrases)
for (auto pCipher : SymmetricCiphers)
for (auto pHash : Hashes)
{
string Phrase = MC(Key, c % 4);
string Key;
Key.resize(pHash->DigestSize());
pHash->CalculateDigest((byte*)Key.data(), (byte const*)Phrase.data(), Phrase.size());
string Result = Decrypt(*pCipher, Key, string((char*)Code, sizeof(Code)), MC(IV, c / 4));
double entropy = ShannonEntropy(Result);
if (entropy < lowest)
lowest = entropy;
if (entropy < 7)
{
cout << entropy << "\n";
cout << pCipher->AlgorithmName() << ", " << MC(Phrase, c % 4) << ", " << MC(IV, c / 4) << ", " << pHash->AlgorithmName() << "\n";
cout << "\n";
}
}
cout << lowest << "\n";
return 0;
}[/code]
Note that this is in C++11. Also it’s the version with password hashes, one needs to remove the hash loops and key hashing lines in order to test with plaintext passwords.
Zero IV is included too, under the empty string. My decrypt routine accepts any size keys and IVs and pads them with zeros or truncates them.
I don’t know if it is worthwhile, it’s such a long shot… then again, long shots are the only thing left 
The problem is the time it takes to test every password, maybe testing for every block cipher it’s just overkill and only the most common ones should be tested. I’ve been about two hours checking and I have not finished the first batch of passwords, for every password there are about two hundred combinations between algoriths and modes of operation(I commented out a couple lines on the code that reduced signicatively the amount of ouput eliminating data file output,but since the message could decrypt as a data file I decided not to put it aside, maybe it can’t and my assumption was wrong). If we knew a single word on the plaintext the whole process would be much faster, just search for the word on the ouput and if it’s not there, none of the passwords were the right one.
Another problem, if the password is not digested, but used as a the key directly, that doubles the amount of decrypted text to guess, (assuming we knew for sure the iv or guessed it right).
Also, it seems that it is common practice to put the iv at the start of the ciphertext, just before the first block, so part of the 752 code could be the iv.
This is supossed to be fun, hunting for clues and interpreting them, and then trying it to see if you were right, not a chore about skimming through lines and lines of wrongly decrypted text for hours and hours. So maybe we got all wrong and the process for solving this is far easier. The interpretation of the clues on the Tempus Omnia Revelant by Gunsrequiem makes sense, maybe we should limit the cipher algorithms to 3DES and DES.
Edit:
And seeing that code I believe you. Actually I only read about gcc, never used, I only know how to code properly on C (and properly may be an exageration) and I used other compiler, but I can understand what the code does, and actually solves the problem of having to skim through tons of output. It’s very late here and I have to get up early tomorrow, I will use your code tomorrow and try other passwords.
Founded in 2004, Leakfree.org became one of the first online communities dedicated to Valve’s Source engine development. It is more famously known for the formation of Black Mesa: Source under the 'Leakfree Modification Team' handle in September 2004.