Topic: Bitcoin; Algoritma Üzerine Yöntemler (Read 33534 times)

Merhaba, ben zamanında bir matematik bilmecesi çözerek bitcoin programcısı Jimmy Song'un "Programming Bitcoin" kursunu bedavaya alma şansına eriştim ve kursta öğrendiklerimi uygulamak için -ve aynı zamanda eğlencesine- bu legacy adreslerden bitcoin aramanıza olanak sağlayan bir site yaptım. Oynamak için bakmak isteyebilirsiniz.
www.findfreebitcoin.com

Eğer 666 veya ilk 10 sayıyı denerseniz insanların gerçekten bu sayı ile türetilen legacy adreslere az da olsa bitcoin gönderdiklerini göreceksiniz 

Bulmacalar için bir kod bu işle uğraşanlar veya bilgisayar 7/24 açık olanlar deneyebilir
bulmacalardaki aralığı girin başlangıç ve bitiş private keyi
aranan adresi girin ve bırakın tarasın bulursa text dosyasına yazdırır, çözülen bulmacalarda deneyebilirsiniz MODÜLLERİ YÜKLEMEYİ UNUTMAYIN!

import hashlib
import ecdsa
import random
import base58
import tkinter as tk
from tkinter import messagebox
from threading import Thread

def private_key_to_compressed_public_key(private_key):
    sk = ecdsa.SigningKey.from_string(private_key, curve=ecdsa.SECP256k1)
    vk = sk.get_verifying_key()
    return (b'\x02' if vk.pubkey.point.y() % 2 == 0 else b'\x03') + vk.to_string()[:32]

def public_key_to_address(public_key):
    sha256_bpk = hashlib.sha256(public_key).digest()
    ripemd160_bpk = hashlib.new('ripemd160', sha256_bpk).digest()
    prefixed_ripemd160_bpk = b'\x00' + ripemd160_bpk
    sha256_1 = hashlib.sha256(prefixed_ripemd160_bpk).digest()
    sha256_2 = hashlib.sha256(sha256_1).digest()
    checksum = sha256_2[:4]
    binary_address = prefixed_ripemd160_bpk + checksum
    address = base58.b58encode(binary_address)
    return address.decode('utf-8')

def generate_random_private_key(start, end):
    return random.randint(start, end).to_bytes(32, byteorder='big')

def search_for_matching_key(target_address, start, end, status_label):
    scanned_keys = 0
    while True:
        private_key = generate_random_private_key(start, end)
        
      
        compressed_pubkey = private_key_to_compressed_public_key(private_key)
        compressed_address = public_key_to_address(compressed_pubkey)
        
        scanned_keys += 1
        status_label.config(text=f"Tarama yapılan private key sayısı: {scanned_keys}")
        root.update_idletasks()
        
        if compressed_address == target_address:
            with open("found_key.txt", "w") as file:
                file.write(f"Matching private key: {private_key.hex()}\n")
            return private_key.hex(), scanned_keys

def start_search():
    target_address = entry_address.get()
    start_range = int(entry_start.get(), 16)
    end_range = int(entry_end.get(), 16)
    
    if len(target_address) == 34 and start_range < end_range:
        status_label.config(text="Arama başlatılıyor...")
        root.update_idletasks()
        # İş parçacığı oluştur
        search_thread = Thread(target=search_key_in_background, args=(target_address, start_range, end_range))
        search_thread.start()
    else:
        messagebox.showerror("Hata", "Geçersiz girişler. Adresi ve private key aralığını kontrol edin.")

def search_key_in_background(target_address, start_range, end_range):
    try:
        matching_key, scanned_keys = search_for_matching_key(target_address, start_range, end_range, status_label)
        if matching_key:
            messagebox.showinfo("Sonuç", f"Eşleşen private key: {matching_key}\nTarama yapılan private key sayısı: {scanned_keys}")
        else:
            messagebox.showwarning("Sonuç", "Eşleşen private key bulunamadı.")
    except Exception as e:
        messagebox.showerror("Hata", f"Bir hata oluştu: {e}")

root = tk.Tk()
root.title("Bitcoin Private Key Bulucu")

tk.Label(root, text="Bitcoin Adresi:").grid(row=0, column=0)
entry_address = tk.Entry(root, width=50)
entry_address.grid(row=0, column=1)

tk.Label(root, text="Başlangıç Private Key (Hex):").grid(row=1, column=0)
entry_start = tk.Entry(root, width=50)
entry_start.grid(row=1, column=1)

tk.Label(root, text="Bitiş Private Key (Hex):").grid(row=2, column=0)
entry_end = tk.Entry(root, width=50)
entry_end.grid(row=2, column=1)

status_label = tk.Label(root, text="Tarama yapılacak...")
status_label.grid(row=4, column=0, columnspan=2)

search_button = tk.Button(root, text="Aramayı Başlat", command=start_search)
search_button.grid(row=3, column=0, columnspan=2)

root.mainloop()

Yıllardır takip edip, esince kurcaladığımız ve sıkılınca bırakıp bir daha kurcaladığımız bir bulmaca
 
https://bitcointalk.org/index.php?topic=1306983.0;topicseen


Eyvallah müdür.

 ..Sıkma canını be, ben senin problemini çözerim.

https://youtu.be/c7pN5imZWw0?t=52

Bu ne demek hocam anlayamadım.

66 nolu bulmaca da çözüldü moralim sıfır sıfır sıfır...

mhancım valla bende tam öyle düşünüyorum . vanity baya süredir GPU  destekli zaten. 12 ve daha fazla GPU lu clusterlar ile işlem baya hızlanıyor.

Günümüz GPU ları da  boru değil hani artık . 

Bazı arkadaşlar indregandi yapıyor bence sesi çıkmıyor     Hatta bir listede baya eskiden beri hareketsiz duran BTC lerin hareket edip cüzdanın sıfırlandığını görmüştüm.

Yapay zeka da ibne kendi yapıyordur, bize yapma başaramazsın der tabi. Öküz gibi process gücü var ondada.    Yap lan  belki olur  demez kesin bize.

Ama bence birçok adres üretip sorgulatmak yerine bence hedef tek 1 adrese odaklanıp onu vanity yapmak daha mantıklı gibi geliyor.  En azından SQL  mesqüel , sorgu işlerine kaynak ayrılmaz.

Yinede böyle güzel sağlam Db olan arkadaş varsa atsın link yahu.  BigDump falan yapar yardırırız, kendinize müslüman olmayın olum paylaşın, forum bura 

Sanılanın aksine bu konuda başarılı sonuçlar alan ve bunu paylaşmayan kişiler olduğunu düşünüyorum.
Bunu düşünmemin bir kaç sebebi var.

1. vanitygen ilk başlarda sadece cpu ile çalışıyordu artık gpu ile çalışan versiyonları da var.
2. çok sistematik bir şekilde 10 larca gpu ile paralel olarak adres üretip bunu bir tam düğümde sorgulamaya başladılar.
3. ürettikleri adres ve private keyleri önce mysql de sonra yetersiz kalınca postgresql da sakladıklarını okuduk.
4. hem sürekli adres üretmeye devam ediyorlar hemde daha önce ürettikleri adreslerinde bakiyelerini de belli aralıklar kontrol ediyorlar.

Buna rağmen yapay zeka boşuna uğraşıyorsunuz diyor.
https://bitcointalk.org/index.php?topic=5503710.new#new

İki kod daha uğraşan arkadaşlara

1. Kod BNB ağındaki sizin tarafınızdan verilen blok aralığındaki blokları tarayarak bakiyesi 0 dan büyük adresleri bir txt dosyasına yazdırır. (Api kullanmadığı için biraz zorlayabilir bazı bloklarda çok fazla adres olmasından kaynaklı)

2. Kod 1. kodda üretilen txt dosyasını hafızaya alıp rasgele private key üretip txt dosyasında bir eşleşmeyle karşılaşırsa başka bir txt dosyasına eşleşen adres ile pk yazdırır....


1. KOD >>>>>>

from web3 import Web3
from web3.middleware import geth_poa_middleware

bsc = Web3(Web3.HTTPProvider('https://bsc-dataseed.binance.org/'))
bsc.middleware_onion.inject(geth_poa_middleware, layer=0)

def check_balance(address):
    balance = bsc.eth.get_balance(address)
    return balance

def get_non_zero_balance_addresses(start_block, end_block):
    non_zero_addresses = set()
    
    for block_num in range(start_block, end_block + 1):
        block = bsc.eth.get_block(block_num, full_transactions=True)
        for tx in block.transactions:
            if tx.to:
                balance = check_balance(tx.to)
                if balance > 0:
                    non_zero_addresses.add((tx.to, Web3.from_wei(balance, 'ether')))
            
            balance = check_balance(tx['from'])
            if balance > 0:
                non_zero_addresses.add((tx['from'], Web3.from_wei(balance, 'ether')))
        
        print(f"Processed block {block_num}/{end_block}")
    
    return non_zero_addresses

def save_to_file(non_zero_addresses, filename='non_zero_balances.txt'):
    with open(filename, 'w') as f:
        for address, balance in non_zero_addresses:
            f.write(f'{address}\n')

def main():
    start_block = 1  # Başlangıç bloğunu belirleyin
    end_block = 3500  # Bitiş bloğunu belirleyin
    non_zero_addresses = get_non_zero_balance_addresses(start_block, end_block)
    save_to_file(non_zero_addresses)
    print(f'{len(non_zero_addresses)} addresses with non-zero balance found and saved to non_zero_balances.txt.')

if __name__ == '__main__':
    main()

2. KOD >>>>

import os
import random
import time
from web3 import Web3
from eth_account import Account

bsc = Web3(Web3.HTTPProvider('https://bsc-dataseed.binance.org/'))

def generate_random_keypair():
    account = Account.create(os.urandom(32))
    return account.key, account.address

def load_addresses(filename='non_zero_balances.txt'):
    addresses = set()
    with open(filename, 'r') as f:
        for line in f:
            if line.startswith('Address:'):
                address = line.split()[1][:-1]
                addresses.add(address)
    return addresses

def save_found_key(address, private_key, filename='found_keys.txt'):
    with open(filename, 'a') as f:
        f.write(f'Address: {address}, Private Key: {private_key}\n')

def main():
    known_addresses = load_addresses()
    print(f'Loaded {len(known_addresses)} known addresses.')

    found = False
    total_attempts = 0
    interval_attempts = 0
    start_time = time.time()

    while not found:
        private_key, address = generate_random_keypair()
        if address in known_addresses:
            print(f'Found a match! Address: {address}, Private Key: {private_key.hex()}')
            save_found_key(address, private_key.hex())
            found = True
        total_attempts += 1
        interval_attempts += 1

        current_time = time.time()
        if current_time - start_time >= 1:
            print(f'{interval_attempts} attempts made in the last second.')
            interval_attempts = 0
            start_time = current_time

        if total_attempts % 1000 == 0:
            print(f'{total_attempts} total attempts made, still searching...')

if __name__ == '__main__':
    main()

aşadaki kodda aynı anda 3 ağda (Eth, Bnb, Matic) kontrol etmenizi sağlar. Bu sefer sizden Private Keyinizi ister önce onun bakiyesini kontrol eder DENEME AMAÇLI ve arayüzlü exe haline getirmedim ki açık kaynak kodlu olsun diye... yine modülleri yüklemeyi unutmayın....


import os
import threading
from web3 import Web3
from eth_account import Account
import tkinter as tk
from tkinter import scrolledtext, messagebox

bsc = Web3(Web3.HTTPProvider('https://bsc-dataseed.binance.org/'))
ethereum = Web3(Web3.HTTPProvider('https://cloudflare-eth.com'))
polygon = Web3(Web3.HTTPProvider('https://polygon-rpc.com'))

def generate_random_keypair():
    """Rastgele bir Ethereum/BSC Keypair üretir."""
    account = Account.create(os.urandom(32))
    return account.key, account.address

def check_balance(address, web3):
    """Belirtilen adresin bakiyesini kontrol eder."""
    balance = web3.eth.get_balance(address)
    return balance

class BSCApp:
    def __init__(self, root):
        self.root = root
        self.root.title("BSC, Ethereum ve Polygon (MATIC) Balance Checker")
        
        self.is_running = False
        
        self.lbl = tk.Label(root, text="Lütfen bakiyesini kontrol etmek istediğiniz private key'i girin:")
        self.lbl.pack(pady=10)
        
        self.private_key_entry = tk.Entry(root, width=50)
        self.private_key_entry.pack(pady=5)
        
        self.start_button = tk.Button(root, text="Başlat", command=self.start_checking)
        self.start_button.pack(pady=5)
        
        self.stop_button = tk.Button(root, text="Durdur", command=self.stop_checking)
        self.stop_button.pack(pady=5)
        
        self.output_text = scrolledtext.ScrolledText(root, width=60, height=15)
        self.output_text.pack(pady=10)
        
        self.found_text = scrolledtext.ScrolledText(root, width=60, height=10, bg='light yellow')
        self.found_text.pack(pady=10)
        
        self.thread = None
    
    def start_checking(self):
        if not self.is_running:
            self.is_running = True
            self.output_text.insert(tk.END, "İşlem başlatıldı...\n")
            self.output_text.see(tk.END)
            self.thread = threading.Thread(target=self.check_balances)
            self.thread.start()
        else:
            messagebox.showwarning("Uyarı", "İşlem zaten çalışıyor.")
    
    def stop_checking(self):
        if self.is_running:
            self.is_running = False
            self.output_text.insert(tk.END, "İşlem durduruldu...\n")
            self.output_text.see(tk.END)
        else:
            messagebox.showwarning("Uyarı", "Zaten çalışan bir işlem yok.")
    
    def check_balances(self):
        user_private_key = self.private_key_entry.get()
        try:
            account = Account.from_key(user_private_key)
        except Exception as e:
            self.output_text.insert(tk.END, f"Geçersiz private key: {e}\n")
            self.is_running = False
            return
        
        user_address = account.address
        user_balance_bsc = check_balance(user_address, bsc)
        user_balance_ethereum = check_balance(user_address, ethereum)
        user_balance_polygon = check_balance(user_address, polygon)
        
        user_balance_bsc_in_bnb = Web3.from_wei(user_balance_bsc, 'ether')
        user_balance_ethereum_in_eth = Web3.from_wei(user_balance_ethereum, 'ether')
        user_balance_polygon_in_matic = Web3.from_wei(user_balance_polygon, 'ether')
        
        self.output_text.insert(tk.END, f"Kullanıcı Adresi: {user_address}\n")
        self.output_text.insert(tk.END, f"BSC Bakiye: {user_balance_bsc_in_bnb} BNB\n")
        self.output_text.insert(tk.END, f"Ethereum Bakiye: {user_balance_ethereum_in_eth} ETH\n")
        self.output_text.insert(tk.END, f"Polygon Bakiye: {user_balance_polygon_in_matic} MATIC\n")
        self.output_text.see(tk.END)
        
        if user_balance_bsc > 0 or user_balance_ethereum > 0 or user_balance_polygon > 0:
            self.found_text.insert(tk.END, f"Kullanıcı Adresi: {user_address}\n")
            self.found_text.insert(tk.END, f"BSC Bakiye: {user_balance_bsc_in_bnb} BNB\n")
            self.found_text.insert(tk.END, f"Ethereum Bakiye: {user_balance_ethereum_in_eth} ETH\n")
            self.found_text.insert(tk.END, f"Polygon Bakiye: {user_balance_polygon_in_matic} MATIC\n")
            self.found_text.insert(tk.END, f"Private Key: {user_private_key}\n\n")
            self.found_text.see(tk.END)
        
        found = False
        counter = 0
        while self.is_running and not found:
            private_key, address = generate_random_keypair()
            balance_bsc = check_balance(address, bsc)
            balance_ethereum = check_balance(address, ethereum)
            balance_polygon = check_balance(address, polygon)
            
            balance_bsc_in_bnb = Web3.from_wei(balance_bsc, 'ether')
            balance_ethereum_in_eth = Web3.from_wei(balance_ethereum, 'ether')
            balance_polygon_in_matic = Web3.from_wei(balance_polygon, 'ether')
            
            self.output_text.insert(tk.END, f"{private_key.hex()}\n")
            self.output_text.insert(tk.END, f"BSC: {balance_bsc_in_bnb} BNB\n")
            self.output_text.insert(tk.END, f"Ethereum: {balance_ethereum_in_eth} ETH\n")
            self.output_text.insert(tk.END, f"Polygon: {balance_polygon_in_matic} MATIC\n")
            self.output_text.see(tk.END)
            
            if balance_bsc > 0 or balance_ethereum > 0 or balance_polygon > 0:
                found = True
                with open("buldumm.txt", "a") as f:
                    f.write(f"Private Key: {private_key.hex()}\n")
                    f.write(f"Address: {address}\n")
                    f.write(f"BSC Balance: {balance_bsc_in_bnb} BNB\n")
                    f.write(f"Ethereum Balance: {balance_ethereum_in_eth} ETH\n")
                    f.write(f"Polygon Balance: {balance_polygon_in_matic} MATIC\n\n")
                self.found_text.insert(tk.END, f"Address: {address}\n")
                self.found_text.insert(tk.END, f"BSC Balance: {balance_bsc_in_bnb} BNB\n")
                self.found_text.insert(tk.END, f"Ethereum Balance: {balance_ethereum_in_eth} ETH\n")
                self.found_text.insert(tk.END, f"Polygon Balance: {balance_polygon_in_matic} MATIC\n")
                self.found_text.insert(tk.END, f"Private Key: {private_key.hex()}\n\n")
                self.found_text.see(tk.END)
            
            counter += 1
            if counter % 1000 == 0:
                user_balance_bsc = check_balance(user_address, bsc)
                user_balance_ethereum = check_balance(user_address, ethereum)
                user_balance_polygon = check_balance(user_address, polygon)
                
                user_balance_bsc_in_bnb = Web3.from_wei(user_balance_bsc, 'ether')
                user_balance_ethereum_in_eth = Web3.from_wei(user_balance_ethereum, 'ether')
                user_balance_polygon_in_matic = Web3.from_wei(user_balance_polygon, 'ether')
                
                self.output_text.insert(tk.END, f"Kullanıcı Adresi: {user_address}\n")
                self.output_text.insert(tk.END, f"BSC Bakiye: {user_balance_bsc_in_bnb} BNB\n")
                self.output_text.insert(tk.END, f"Ethereum Bakiye: {user_balance_ethereum_in_eth} ETH\n")
                self.output_text.insert(tk.END, f"Polygon Bakiye: {user_balance_polygon_in_matic} MATIC\n")
                self.output_text.see(tk.END)

if __name__ == "__main__":
    root = tk.Tk()
    app = BSCApp(root)
    root.mainloop()
 

slm herkese

bnb ağı için basit bir kod kullanmak isteyenler için...
kodu test etmek için sizden bir adres girmenizi ister girilen adresin bakiyesini kontrol eder daha sonrasında rasgele bnb adresi üretip bakiyesini kontrol eder bulursa yazdırır...

modülleri yüklemeyi unutmayın

import os
from web3 import Web3
from eth_account import Account

# BSC (Binance Smart Chain) bağlantısı
bsc = Web3(Web3.HTTPProvider('https://bsc-dataseed.binance.org/'))

def generate_random_keypair():
    """Rastgele bir Ethereum/BSC Keypair üretir."""
    account = Account.create(os.urandom(32))
    return account.key, account.address

def check_balance(address):
    """Belirtilen adresin BNB bakiyesini kontrol eder."""
    balance = bsc.eth.get_balance(address)
    return balance

def main():
    # Kullanıcıdan bir BNB adresi al
    user_address = input("Lütfen bakiyesini kontrol etmek istediğiniz BNB adresini girin: ")
    user_balance = check_balance(user_address)
    user_balance_in_bnb = Web3.from_wei(user_balance, 'ether')
    print(f"Kullanıcı Adresi: {user_address}, Bakiye: {user_balance_in_bnb} BNB")
   
    found = False
    while not found:
        private_key, address = generate_random_keypair()
        balance = check_balance(address)
        balance_in_bnb = Web3.from_wei(balance, 'ether')
        print(f"Address: {address}, Balance: {balance_in_bnb} BNB")
        if balance > 0:
            found = True
            with open("bulundu1.txt", "a") as f:
                f.write(f"Private Key: {private_key.hex()}\n")
                f.write(f"Address: {address}\n")
                f.write(f"Balance: {balance_in_bnb} BNB\n\n")
            print(f"Found an address with balance > 0: {address}")
            print(f"Private Key: {private_key.hex()}")

if __name__ == "__main__":
    main()

Konuyu güncellemek adına yaptığınız çalışmanın sürecini maddeleyerek yazabilir misiniz? Hem tarihe not düşmek hem mevcut ile yeni başlayacaklara yol gösterici olabilir.

Teşekkürler.

Bir dönem üzerinde uğraştık adresler oluşturduk vsvs ancak olduğu gibi kaldı tblarca cüzdan oluşturduk ancak sonuç 0  bizde vazgeçtik.

Birde arkadaşlar konu dışı olacak ama ether için güvenli vanitygen varmıdır?

İddia değil gerçek olması için ispat gerekir. İspatı ortaya koymanızı engelleyen bir durum yok.

2 ^ 256 - 1 olasılıklı havuzdan 1 milyon adet oluşturmayı bedava piyango biletine benzetmek çok makul bir hareket değil. Geriye kalan olasılık hala akıl almaz derecede büyüktür. Yaklaşık 2 ^ 236 - 1.

Yine yaklaşık 900.000 adresin 1BTC ve üzerine sahip olduğunu eklediğinizde bu bakiyeye sahip bir adrese ulaşma olasılığı 1 / (2 ^ 216 - 1) olasılığından daha küçüktür.

Mekanın sahibi  geldi,

işler artın farklı yönlere gidiyor, artık güvenlik diye bir şey kalmadı.
LevenT'in yazdığı gibi. Birden Tüm bitcoin'lerimiz uçar.

https://bitcointalksearch.org/topic/bitcoin-greatest-vulnerability-1516755

Şu anda durum daha vahim durumda. Hayır bu bir iddia değil gerçek.

Yaklaşık 2 Tb veri oluşturdum belli bir kaç wallet başlangıç adresini baz alarak bir tane bile bulamadım. Bu yolla bir şeyin karşımıza çıkması akşam üstü ayı seyrederken uzaylıların bize el sallaması kadar olası.

Mugt senin bu özverin ile belki bir gün keşfedilmemiş tüm hesaplar keşfedilecek. 

Konu açılalı 4 yıl olmuş, kendi adıma konuşacak olursam araştırma ve çalışmalarım devam ediyor. 4 yıl içerisinde yeni onlarca yazılım, internet siteleri, makaleler yayınlandı. Farklı denemelerin yanında benzerlik havuzum terabyte'larca oldu. Aklın yolu bir, her ne kadar habersiz olsamda yayınlanan makalelerle bazı noktalarda aynı işlemleri yaptığımı gördüm. Geçen sürede piyasadaki koin adedinin 10 kat artmasıyla, yeni adres formatlarında da kontrol edip, yeni koin adreslerinde de kontrol ediyorum. Denk gelen var mı? Evet var ama hala ufak meblağ'lar 

Ne oldu bu iş ?

Bu çözüyor dediğiniz zaten bir bulmaca, ilk önce 256 adrese transfer edilen toplam 32 btc nin bulunması için.

Bulmacanın yaratıcısı nasıl bil yol izledi bilinmiyor, tahminler var ama doğru bir hesaplama yok


ilk adres 1 bit sonra 2 bit 3 bit diye gidiyor

---
----

100 105 110 bitlik adresler çözülmesine rağmen daha ufak olan 64 bitlik adres çözülememiş mesela.
60 ve 65 çözülmüş...

256 bit altındaki o adreslerin kolay çözülmesinin bir nedeni de pubkey inin bilinmesi, python ile pubkey ve bit ilişkisi ile arama yapan bir kod var.

63 ile 65 bit arasındaki "ufak" bir değeri bulmak bu kadar zor iken, oluşan çoğu adresin 2**255 2**256 arasında olduğunu düşünürsek bu galakside dolu adres bulmak o kadar kolay değil...