I submitted a 366 character long text message which included my bitcoin address. It also had four full sentences but it didn't appear too. Apparently the spam filter knocks off messages with a bitcoin address if it's submitted from new members or/and members without many posts.  

What you posted weren't the actual raw private keys but the base58 encoded and WIF formatted version of the private keys with the information stating it's uncompressed.

The hex representation of a base58 encoded and WIF formatted uncompressed key is:
80 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX YYYYYYYY
The hex representation of a base58 encoded and WIF formatted compressed key is:
80 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 01 YYYYYYYY
where XX is the raw private key and YY the checksum.

Your question regarding "how many invalid keys are in between" is ambiguous. You might also consider to open a new thread to reach appropriate audience.

I was already utilizing the point addition function instead of point multiplication.

No. Currently I don't try to discover any values above 2⁴⁰.
I'll continue the search if:

• I learn how to code on GPU one day
• I gain access to many computers equipped with a powerfull GPU

A GPU cracker would take at most ~a year for solving the next 2⁵¹ address at 35,000,000 keys/s. I guess it will be cracked too in future, but for fun and not for money.

I don't know who made this pizzle.

I was involved in the challenge and earned some BTC. I speedhacked the code in the mealtime at work straight after I saw the puzzle back in January 2015 and started it on some server remotely. The first version could do about 100,000 keys/s using a CPU. After some improvements I boosted the rate to 700,000 keys/s on a single computer. Later I ran it on many computers and checked million of keys/s. Luckly I could recycle the code later in the August 2015 puzzle at https://bitcointalk.org/index.php?topic=1144807.0
I had no time to learn how to code on a GPU.

Vanitygen doesn't support this way of address generation but you can create your own customized program by copying some code off vanitygen.

It doesn't make sense to use the CPU version anymore if you plan to brute force the keys above 2⁵⁰.

Log(2) = Logarithm to the base 2 of the decimal value.

Brute force

Here are all keys from #1 to #40:

Bits	Hex	Decimal	Binary	As raw text	Log(2)
1	0000000001	1	░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█		0
2	0000000003	3	░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██		1.5849625007212
3	0000000007	7	░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███		2.8073549220576
4	0000000008	8	░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█░░░		3
5	0000000015	21	░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█░█░█		4.3923174227788
6	0000000031	49	░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██░░░█	1	5.6147098441152
7	000000004C	76	░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█░░██░░	L	6.2479275134436
8	00000000E0	224	░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███░░░░░	à	7.8073549220576
9	00000001D3	467	░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███░█░░██	Ó	8.8672787397097
10	0000000202	514	░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█░░░░░░░█░		9.0056245491939
11	0000000483	1155	░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█░░█░░░░░██	ƒ	10.173677136303
12	0000000A7B	2683	░░░░░░░░░░░░░░░░░░░░░░░░░░░░█░█░░████░██	{	11.389631339261
13	0000001460	5216	░░░░░░░░░░░░░░░░░░░░░░░░░░░█░█░░░██░░░░░	`	12.348728154231
14	0000002930	10544	░░░░░░░░░░░░░░░░░░░░░░░░░░█░█░░█░░██░░░░	)0	13.364134655008
15	00000068F3	26867	░░░░░░░░░░░░░░░░░░░░░░░░░██░█░░░████░░██	hó	14.713547616913
16	000000C936	51510	░░░░░░░░░░░░░░░░░░░░░░░░██░░█░░█░░██░██░	É6	15.652564919611
17	000001764F	95823	░░░░░░░░░░░░░░░░░░░░░░░█░███░██░░█░░████	vO	16.548084361224
18	000003080D	198669	░░░░░░░░░░░░░░░░░░░░░░██░░░░█░░░░░░░██░█		17.600007248708
19	000005749F	357535	░░░░░░░░░░░░░░░░░░░░░█░█░███░█░░█░░█████	tŸ	18.447724952285
20	00000D2C55	863317	░░░░░░░░░░░░░░░░░░░░██░█░░█░██░░░█░█░█░█	,U	19.719530872026
21	00001BA534	1811764	░░░░░░░░░░░░░░░░░░░██░███░█░░█░█░░██░█░░	¥4	20.788963611792
22	00002DE40F	3007503	░░░░░░░░░░░░░░░░░░█░██░████░░█░░░░░░████	-ä	21.520134745822
23	0000556E52	5598802	░░░░░░░░░░░░░░░░░█░█░█░█░██░███░░█░█░░█░	UnR	22.416686729788
24	0000DC2A04	14428676	░░░░░░░░░░░░░░░░██░███░░░░█░█░█░░░░░░█░░	Ü*	23.782435585948
25	0001FA5EE5	33185509	░░░░░░░░░░░░░░░██████░█░░█░████░███░░█░█	ú^å	24.984050066697
26	000340326E	54538862	░░░░░░░░░░░░░░██░█░░░░░░░░██░░█░░██░███░	@2n	25.700781261713
27	0006AC3875	111949941	░░░░░░░░░░░░░██░█░█░██░░░░███░░░░███░█░█	¬8u	26.738278526959
28	000D916CE8	227634408	░░░░░░░░░░░░██░██░░█░░░█░██░██░░███░█░░░	‘lè	27.762143403295
29	0017E2551E	400708894	░░░░░░░░░░░█░██████░░░█░░█░█░█░█░░░████░	âU	28.577979290797
30	003D94CD64	1033162084	░░░░░░░░░░████░██░░█░█░░██░░██░█░██░░█░░	=”Íd	29.944419458082
31	007D4FE747	2102388551	░░░░░░░░░█████░█░█░░███████░░███░█░░░███	}OçG	30.969382178281
32	00B862A62E	3093472814	░░░░░░░░█░███░░░░██░░░█░█░█░░██░░░█░███░	¸b¦.	31.526580209328
33	01A96CA8D8	7137437912	░░░░░░░██░█░█░░█░██░██░░█░█░█░░░██░██░░░	©l¨Ø	32.732759144628
34	034A65911D	14133072157	░░░░░░██░█░░█░█░░██░░█░██░░█░░░█░░░███░█	Je‘	33.718356052473
35	04AED21170	20112871792	░░░░░█░░█░█░███░██░█░░█░░░░█░░░█░███░░░░	®Ò p	34.227400038686
36	09DE820A7C	42387769980	░░░░█░░███░████░█░░░░░█░░░░░█░█░░█████░░	ނ |	35.302929017097
37	1757756A93	100251560595	░░░█░███░█░█░███░███░█░█░██░█░█░█░░█░░██	Wuj“	36.544833738747
38	22382FACD0	146971536592	░░█░░░█░░░███░░░░░█░█████░█░██░░██░█░░░░	"8/¬Ð	37.096745824716
39	4B5F8303E9	323724968937	░█░░█░██░█░██████░░░░░██░░░░░░█████░█░░█	K_ƒ é	38.235977688802
40	E9AE4933D6	1003651412950	███░█░░██░█░███░░█░░█░░█░░██░░████░█░██░	é®I3Ö	39.868395419757

Yes and no. I created one bruteforce tool which could do 100,000 tries in one second which was being used for finding brain wallets only.

For this challenge, I created another brute force tool which did following:
1. Split the guesses in many batches
2. Assemble the first guess in the batch as a base58 string
3. Then do a base58_decode which outputs a 37 byte binary
4. Take byte #1 to #32 (counting from #0) and load it into the EC library (yes, you can ignore the checksum here)
5. Do an EC point multiplication p=G*k where p=public key, G=base point and k=your first guess
6. If ripemd160(sha256(p)) matches target, alert and stop
7. Do an EC point addition p=p+G and goto 6. until 58ⁿ/2³² repetitions has been made. n is the number of characters missing at the end
8. Open a new batch and goto 2

This gave me the boost to try 500,000 valid keys in one second.
My computer found the key in under 4 hours instead of cracking for days because I told the bruteforcer to try a limited character set first. It was:

• Alphabet 6Fabcdefghijkmnopqrstuvwxyz for puzzle #9, char #1,2,4,5
• Alphabet 6abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ for puzzle #9, char #3

Puzzle #10 was auto-solved by the ECDSA point addition loop.


I would be happy to hear from the anonymous cracker what his/her approach was because I'm curious.

Finally I managed to find the solution by searching 5Juu2CkB3XFdBzEcyH9dypNhDZ8fXgh6RQwwbo5* in 3h:50m:39s using an Intel i7-4xxx

The solution is:
#3 = XFdBz
#9 = ueBaf
#10 = eGYoMm5

I thank you very much for this interesting puzzle.

Correct.

I know of two approaches to brute force crack a private key if some of the unknown characters are on the end:

Approach #1: Checking against checksum
1. Assemble your guess as a WIF string (base58)
2. Then do a base58_decode which outputs a 1+32+4=37 byte (1 extra byte when compressed but this puzzle has an uncompressed key).
3. Then re-calculate the checksum
4. If it matches, alert, else goto 1.
Chance of a false positive: 1:2³²

Approach #2: Check against hash160 (this is the way I go)
1. Split your guesses in many batches
2. Assemble the first guess in the batch as a base58 string
3. Then do a base58_decode which outputs a 37 or 38 byte binary
4. Take byte #1 to #32 (counting from #0) and load it into your EC library (yes, you can ignore the checksum here)
5. Do an EC point multiplication p=G*k where p=public key, G=base point and k=your first guess
6. If ripemd160(sha256(p)) matches target, alert and stop
7. Do an EC point addition p=p+G and goto 6. until 58ⁿ/2³² repetitions has been made. n is the number of characters missing at the end
8. Open a new batch and goto 2

Approach #2 has advantages if #10 is unknown because large parts of #10 are sitting in the checksum. When directly dealing with the internal binary representation of the private key using EC math, you're "skipping" all possible invalid WIF private key combinations at once.
Approach #1 could be the better choice if you're sure that you have #10 correct.

Currently I don't do any bruteforce anymore because I ran out of ideas for #9. As soon I get new clues, I'll resume my bruteforce.


Note:
Some peoples asked for code (here/PM):
I'm handing out this hint for free but you have to do the coding work yourself. I'm fearing getting deanonymized if uploading my code here because it heavyly relies on code from other projects made by me.

Good job.

I could crack it if #3 or #9 were known. On #3 I don't have the right book, on #9 I'm out of ideas now.

My "clue" for #9 I'm now sharing is:
4(1)x5(2)x1(1)x1(2)x*6* __-__

4(1)x
5(2)x
1(1)x
1(2)x
*6*
__-__

First: 4(1) - x = small
Second: 5(2) - x = small
Third: 1(1) - x = small
Fourth: 1(2) - x = small
= xxxx "four small letters" hinting

xxxx*6* + __-__ order hint: xx6xx

Then I bruteforced all valid key ranges from:
5Juu2CkB3AAaAaEcyH9dypNhDZ8fXgh6RQwwbo5xxxxx to
5Juu2CkB3ZZzZzEcyH9dypNhDZ8fXgh6RQwwbo5xxxxx

with xxxxx (#9) =
je6ba
po6ja
pu6ba
su6ba
jo6ja
ja6ja
hh6do (dont make it harder ... word(char))
thdo6 (dont make it harder then ... cancel third word "it" because "-" is interpreted as "cancel it" - in "__-__ ")
so6an
ud6as (derived from Udas)
di6oh (Oh dear ... word(char))
ue6ba (derived from ueBa6 posted here)
jm6jm n(1)=person, start from left, n(2)=person, start from right
pd6ba (Judas->Udas name(char))
pdBa6 (Judas->Udas & 6 = lower case)
ueBa6 (posted)
us6jc (from "jesus" and "christus", char(word#))
ii6th (What it really is: 1=The Last Supper, 2=Leonardo da Vinci, 3=Milan, 4=Italy - 5=visitor information)
UeBa6 (ueBa6 with big U)
ay6vr (Vacation Reply)
eo6ff (Hex bytes: byte(nibble))
eoFff (Hex bytes: *6*=F -> __-__)
sd6ba
each #3 from AAaAa to ZZzZz, means all valid private keys for #10

still no luck.

Apparently I'm too dumb for cracking #9 or the cracker has the right book or both

Another hint for combatants who are struggling like me: most of the chars in #10 are sitting in the checksum part of the B58 private key.

I think we should also try to solve #9. The casing of #3 which is XXxXx (AAaAa-ZZzZz) is more clear than the casing of #9.

I was using a self made program which directly loads the OpenSSL library and does (simplified pseudocode):

edit: corrected major error in pseudocode -- @ 19:53 UTC

I tried the basic key 5Juu22CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt with replacing each character with each possible letter, e.g.:
5J1u22CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt <--first try
5J2u22CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt <-- second try
5J3u22CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt <-- ...
...
5Jyu22CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt
5Jzu22CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt
5Ju122CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt
5Ju222CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt
...
5Juz22CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt
5Juu12CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt
...
5Juuz2CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt
...
5Juu21CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt
...
5Juu221kB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt
...
...
5Juu22CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoT1
...
5Juu22CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTz <-- last try

then with two letters:
5J1122CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt
...
5J1u12CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt
...

No luck!  

Then tried also all toggling case combinations for up to three characters:
5Juu22CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5jeBa6dRNoTt <-- basic key
5JUu22CkB3eAaBpEcyH9dypNhDN8fZgh6rqwwbo5jeBa6dRNoTt <-- example

Again ... no luck.

Finally, I tried every possible private key starting with:

5Juu22CkB3EAaBpEcyH9dypNhDN8fZgh6Rqwwbo5	(11 chars missing at the end)	= 5811/232 = rougly 5 800 000 000 combinations
5Juu22CkB3NAaBpEcyH9dypNhDN8fZgh6Rqwwbo5	(11 chars missing at the end)	= 5811/232 = rougly 5 800 000 000 combinations
5Juu22CkB3EAaBpEcyH9dypNhLN8oZgh6Rqwwbo5	(11 chars missing at the end)	= 5811/232 = rougly 5 800 000 000 combinations
5Juu22CkB3NAaBpEcyH9dypNhLN8oZgh6Rqwwbo5	(11 chars missing at the end)	= 5811/232 = rougly 5 800 000 000 combinations
5Juu22CkB3EAaBpEcyH9dypNhDZ8fXgh6Rqwwbo5	(11 chars missing at the end)	= 5811/232 = rougly 5 800 000 000 combinations
5Juu22CkB3NAaBpEcyH9dypNhDZ8fXgh6Rqwwbo5	(11 chars missing at the end)	= 5811/232 = rougly 5 800 000 000 combinations
5Juu22CkB3EAaBpEcyH9dypNhDN8fZgh6RQwwbo5	(11 chars missing at the end)	= 5811/232 = rougly 5 800 000 000 combinations

Total Keys: 7*58¹¹:2³² currently tried = rougly 40 700 000 000 combinations

No luck  

I think at least one answer in the document is horrible wrong.

I have Windows 10 locked in a virtual machine. It runs pretty good but the UI looks cheap and it feels like I turned my PC into an oversized smartphone. The only real advantage I see now are virtual desktops.

I have an old copy of brainwallet.org running because of the useful utilities and just rechecked it using a network inspector few minutes ago: it didn't store or send the passphrases I entered.

I'm thinking about follow possibilities:

• He used this address with a software which had the RNG implementation faulty, his private key was exposed to the cracker after recovering the R value
• brainwallet.org turned into a full scam site a few hours to days before the shutdown
• His passphrase was too weak, example: wrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhwrhw rhwrh has 84 characters but it's still guessable
• He had the private key in the clipboard while pressing CTRL+v in the wrong browser window without even noticing
• He had the private key imported into an insecure wallet software and forgot about it

Before doing some business, I'm thinking about the motivation of my business partner. If the motivation is sharp & clear, then I'm in. If it's shady, one common example is money coming out from nowhere, then I'm refusing.

-> I never got scammed >$1. If I get scammed anyways, I'll improve my risk management.

You could use multithreading to speed things up a bit.

If you want to check a bigger amount of brain wallets in a reasonable time, you have to study the underlying ECDSA math.

Just do it for satifying your curiosity, don't expect to get rich if you intent to take the funds because this bitcoin network is already being monitored by bots with very low latency network connections.

For your curiosity:
I had already checked the blockchain using a 1 500 000 000 entries wordlist and a self made cracker operating at 100000 keys/s. utilizing all CPU cores and found about ~18500 bitcoin addresses which had funds, many of them were created during a brain wallet spam attack launched on 31.08.2013.