While it may lead nowhere, I have to disagree on your count, Virge.
There are 2^64 keys. That is 18,446,744,073,709,551,616 or 18 billion billions.
Keys are grouped in blocks. Each block is 2^28 keys. That is 268,435,456 or 268 million keys per block.
So, divide 18,446,744,073,709,551,616 by 268,435,456 you get 68,719,476,736 or 68 billions blocks.
Everybody knows that 68,719,476,736 = 2^36.
If you remove (bits in keyspace=64) from (bits in 1 block=28) you get 64-28=36. How strange.
What misled you is that most blocks we get have an hex address of ########:00000000, like E8EEEEF5:00000000. But if you look at the logs more closely, and you've not been doing large blocks only, you'll find some blocks with an address of ########:#0000000 which means a block always start at an address of 9 chars, not 8.
That is 36 bits, not 32. (I'll use char instead of byte, cause we're talking unsigned values here, but it still means 8 bits anyway).
So every block in the overall table needs 36 bits to store the address. Then we have the participant. I'm sure as hell dnet don't store the full email in the database. That has to be in a separate participants table.
Instead, they would store the participant's ID number. To go simple, they may store the ID in a 32^bit value, allowing for 4 billion participants (a bit optimistic, hey ?). Which would give us 36+32=68 bits records.
Or maybe they tried to fit it along with the block address into a multiple of 8 to use an integer number of chars for both fields (know how processing are faster and easier to implement with chars than bits ?). That gives the possibility of 36+20=56 or 7 chars (20 bits : 1 million participants).
We are now over 330,000 participants, so maybe (I hope) they planned ahead and chose the next possibility : 36+28=64 or 7 chars (28 bits : 268 million participants)
So a record in the main table would be between 56 (too few) and 68 (too much) bits, that is between 7 and 8,5 bytes, 8 bytes being an optimal value IMO. But we have more fields to add. The first one would be the date when the block was cracked. I, for one, would store that in an value that represents the offset of the date since the project began.
We can only guess how long they planned the project to last, but using 12 bits allow for a 4096 days project, and every additionnal bit allows for twice longer.
Other values sent by the client are the client build (again, 12 bits allow for 4096 revisions), OS and CPU type (8 bits or 256 values seem to be enough for each).
Also, I suppose the database adds an internal field for the record count. I suppose Sybase uses 64 bits indexes to handle over 68 billion records in a table, as the databases I use can theoretically store a max of 4 billion (32 bits adresses), and I have never had a table with more than 150,000. I know of a few DBAs using the same (paradox) and have a few tens of millions, but not more.
So a (really) blind guesstimate would be around 64+12+12+8+8+64=168 bits, or 21 chars per block.
21x68,719,476,736=1,443,109,011,456 bytes or 1.4TBytes. Funny that we get the same result with a different approach.
Though there may be a lot of bad estimates here, and maybe they don't store all of the above values in the final table to save space.
Should we have guessed right, the project is now about 40% complete, and dnet would have a main result table of 0.4*1.4=0.56 TB or 560 Gigs. To which we must add the participants table, the teams table, and the participants history table. I'll leave it to Decibel (or is it Moose ?) to give more accurate info after all.
/edit speelcheker !