Téléchargement VanitySearch - Téléchargement du code source VanitySearch

VanitéRecherche

VanitySearch est un outil de recherche de préfixes d'adresse Bitcoin. Si vous souhaitez générer des clés privées sécurisées, utilisez l'option -s pour saisir votre phrase secrète qui sera utilisée pour générer une clé de base comme pour la norme BIP38 ( VanitySearch.exe -s "My PassPhrase" 1MyPrefix ). Vous pouvez également utiliser VanitySearch.exe -ps "My PassPhrase" qui ajoutera une graine crypto sécurisée à votre phrase secrète.
VanitySearch peut ne pas calculer une bonne taille de grille pour votre GPU, alors essayez différentes valeurs en utilisant l'option -g afin d'obtenir les meilleures performances. Si vous souhaitez utiliser des GPU et des CPU ensemble, vous obtiendrez de meilleures performances en conservant un cœur de CPU pour gérer les échanges GPU/CPU (utilisez l'option -t pour définir le nombre de threads du CPU).

Fonctionnalité

Arithmétique de taille fixe
Inversion modulaire rapide (décalage droit retardé 62 bits)
SecpK1 Multiplication modulaire rapide (2 étapes pliant 512 bits à 256 bits en utilisant des chiffres de 64 bits)
Utilisez certaines propriétés de la courbe elliptique pour générer plus de clés
Algorithme de hachage sécurisé SSE SHA256 et RIPEMD160 (CPU)
Prise en charge de plusieurs GPU
Optimisation CUDA via l'assemblage PTX en ligne
Semence protégée par pbkdf2_hmac_sha512 (BIP38)
Prise en charge des adresses P2PKH, P2SH et BECH32
Prise en charge de l'adresse personnalisée à clé partagée

Sujet de discussion

Discussion sur VanitySearch@bitcointalk

Usage

Vous pouvez télécharger la dernière version depuis https://github.com/JeanLucPons/VanitySearch/releases

 VanitySearch [-check] [-v] [-u] [-b] [-c] [-gpu] [-stop] [-i inputfile]
             [-gpuId gpuId1[,gpuId2,...]] [-g g1x,g1y,[,g2x,g2y,...]]
             [-o outputfile] [-m maxFound] [-ps seed] [-s seed] [-t nbThread]
             [-nosse] [-r rekey] [-check] [-kp] [-sp startPubKey]
             [-rp privkey partialkeyfile] [prefix]

 prefix: prefix to search (Can contains wildcard '?' or '*')
 -v: Print version
 -u: Search uncompressed addresses
 -b: Search both uncompressed or compressed addresses
 -c: Case unsensitive search
 -gpu: Enable gpu calculation
 -stop: Stop when all prefixes are found
 -i inputfile: Get list of prefixes to search from specified file
 -o outputfile: Output results to the specified file
 -gpu gpuId1,gpuId2,...: List of GPU(s) to use, default is 0
 -g g1x,g1y,g2x,g2y, ...: Specify GPU(s) kernel gridsize, default is 8*(MP number),128
 -m: Specify maximun number of prefixes found by each kernel call
 -s seed: Specify a seed for the base key, default is random
 -ps seed: Specify a seed concatened with a crypto secure random seed
 -t threadNumber: Specify number of CPU thread, default is number of core
 -nosse: Disable SSE hash function
 -l: List cuda enabled devices
 -check: Check CPU and GPU kernel vs CPU
 -cp privKey: Compute public key (privKey in hex hormat)
 -kp: Generate key pair
 -rp privkey partialkeyfile: Reconstruct final private key(s) from partial key(s) info.
 -sp startPubKey: Start the search with a pubKey (for private key splitting)
 -r rekey: Rekey interval in MegaKey, default is disabled

Exemple (Windows, Intel Core i7-4770 3,4 GHz 8 cœurs multithread, GeForce GTX 1050 Ti) :

 C:C++VanitySearchx64Release>VanitySearch.exe -stop -gpu 1TryMe
VanitySearch v1.17
Difficulty: 15318045009
Search: 1TryMe [Compressed]
Start Fri Jan 31 08:12:19 2020
Base Key: DA12E013325F12D6B68520E327847218128B788E6A9F2247BC104A0EE2818F44
Number of CPU thread: 7
GPU: GPU #0 GeForce GTX 1050 Ti (6x128 cores) Grid(48x128)
[251.82 Mkey/s][GPU 235.91 Mkey/s][Total 2^32.82][Prob 39.1%][50% in 00:00:12][Found 0]
PubAddress: 1TryMeJT7cfs4M6csEyhWVQJPAPmJ4NGw
Priv (WIF): p2pkh:Kxs4iWcqYHGBfzVpH4K94STNMHHz72DjaCuNdZeM5VMiP9zxMg15
Priv (HEX): 0x310DBFD6AAB6A63FC71CAB1150A0305ECABBE46819641D2594155CD41D081AF1

 C:C++VanitySearchx64Release>VanitySearch.exe -stop -gpu 3MyCoin
VanitySearch v1.11
Difficulty: 15318045009
Search: 3MyCoin [Compressed]
Start Wed Apr  3 14:52:45 2019
Base Key:FAF4F856077398AE087372110BF47A1A713C8F94B19CDD962D240B6A853CAD8B
Number of CPU thread: 7
GPU: GPU #0 GeForce GTX 1050 Ti (6x128 cores) Grid(48x128)
124.232 MK/s (GPU 115.601 MK/s) (2^33.18) [P 47.02%][50.00% in 00:00:07][0]
Pub Addr: 3MyCoinoA167kmgPprAidSvv5NoM3Nh6N3
Priv (WIF): p2wpkh-p2sh:L2qvghanHHov914THEzDMTpAyoRmxo7Rh85FLE9oKwYUrycWqudp
Priv (HEX): 0xA7D14FBF43696CA0B3DBFFD0AB7C9ED740FE338B2B856E09F2E681543A444D58

 C:C++VanitySearchx64Release>VanitySearch.exe -stop -gpu bc1quantum
VanitySearch v1.11
Difficulty: 1073741824
Search: bc1quantum [Compressed]
Start Wed Apr  3 15:01:15 2019
Base Key:B00FD8CDA85B11D4744C09E65C527D35E231D19084FBCA0BF2E48186F31936AE
Number of CPU thread: 7
GPU: GPU #0 GeForce GTX 1050 Ti (6x128 cores) Grid(48x128)
256.896 MK/s (GPU 226.482 MK/s) (2^28.94) [P 38.03%][50.00% in 00:00:00][0]
Pub Addr: bc1quantum898l8mx5pkvq2x250kkqsj7enpx3u4yt
Priv (WIF): p2wpkh:L37xBVcFGeAZ9Tii7igqXBWmfiBhiwwiKQmchNXPV2LNREXQDLCp
Priv (HEX): 0xB00FD8CDA85B11D4744C09E65C527D35E2B1D19095CFCA0BF2E48186F31979C2

Générer une adresse personnalisée pour un tiers à l'aide d'une clé partagée

Il est possible de générer une adresse personnalisée pour un tiers de manière sûre à l'aide d'une clé partagée.
Par exemple, Alice veut un joli préfixe mais n'a pas de puissance CPU. Bob dispose de la puissance CPU demandée mais ne peut pas connaître la clé privée d'Alice, Alice doit utiliser une clé partagée.

Étape 1

Alice génère une paire de clés sur son ordinateur puis envoie la clé publique générée et le préfixe recherché à Bob. Cela peut se faire par email, rien n'est secret. Néanmoins, Alice doit conserver en toute sécurité la clé privée et ne pas l'exposer.

 VanitySearch.exe -s "AliceSeed" -kp
Priv : L4U2Ca2wyo721n7j9nXM9oUWLzCj19nKtLeJuTXZP3AohW9wVgrH
Pub  : 03FC71AE1E88F143E8B05326FC9A83F4DAB93EA88FFEACD37465ED843FCC75AA81

Remarque : La paire de clés est une paire de clés SecpK1 standard et peut être générée avec un logiciel tiers.

Étape 2

Bob exécute VanitySearch en utilisant la clé publique d'Alice et le préfixe recherché.

 VanitySearch.exe -sp 03FC71AE1E88F143E8B05326FC9A83F4DAB93EA88FFEACD37465ED843FCC75AA81 -gpu -stop -o keyinfo.txt 1ALice

Il génère un fichier keyinfo.txt contenant la clé privée partielle.

 PubAddress: 1ALicegohz9YgrLLa4ADCmam7X2Zr6xJZx
PartialPriv: L2hbovuDd8nG4nxjDq1yd5qDsSQiG8xFsAFbHMcThqfjSP6WLg89

Bob renvoie ce fichier à Alice. Cela peut également se faire par courrier électronique. La clé privée partielle ne permet à personne de deviner la clé privée finale d'Alice.

Étape 3

Alice peut alors reconstruire la clé privée finale en utilisant sa clé privée (celle générée à l'étape 1) et le keyinfo.txt de Bob.

 VanitySearch.exe -rp L4U2Ca2wyo721n7j9nXM9oUWLzCj19nKtLeJuTXZP3AohW9wVgrH keyinfo.txt

Pub Addr: 1ALicegohz9YgrLLa4ADCmam7X2Zr6xJZx
Priv (WIF): p2pkh:L1NHFgT826hYNpNN2qd85S7F7cyZTEJ4QQeEinsCFzknt3nj9gqg
Priv (HEX): 0x7BC226A19A1E9770D3B0584FF2CF89E5D43F0DC19076A7DE1943F284DA3FB2D0

Comment ça marche

Fondamentalement, le -sp (clé publique de démarrage) ajoute la clé publique de départ spécifiée (appelons-la Q) aux clés de départ de chaque thread. Cela signifie que lorsque vous effectuez une recherche (en utilisant -sp), vous ne recherchez pas addr(kG) mais addr(k _part .G+Q) où k est la clé privée dans le premier cas et k _part la "clé privée partielle " dans le deuxième cas. G est le point générateur SecpK1.
Ensuite, le demandeur peut reconstruire la clé privée finale en faisant k _partie + k _secret (mod n) où k _partie est la clé privée partielle trouvée par le chercheur et k _secret est la clé privée de Q (Q = k _secret .G). C'est le but de l'option -rp.
Le chercheur a trouvé une correspondance pour addr(k _part .G+k _secret .G) sans connaître k _secret , le demandeur dispose donc de l'adresse recherchée addr(k _part .G+Q) et de la clé privée correspondante k _part +k _secret ( mod n). Le chercheur n'est pas capable de deviner cette clé privée finale car il ne connaît pas k _secret (il ne connaît que Q).

Remarque : Cette explication est simplifiée, elle ne prend pas en compte les optimisations de symétrie et d'endomorphisme mais l'idée est la même.

Essayer d'attaquer une liste d'adresses

L'adresse Bitcoin (P2PKH) est constituée d'un hash160 (affiché au format Base58) ce qui signifie qu'il existe 2 ¹⁶⁰ adresses possibles. Une fonction de hachage sécurisée peut être considérée comme un générateur de pseudo-nombres, elle transforme un message donné en un nombre aléatoire. Dans ce cas, un nombre (uniformément distribué) compris dans la plage [0,2 ¹⁶⁰ ]. Ainsi, la probabilité d'atteindre un nombre particulier après n essais est de 1-(1-1/2 ¹⁶⁰ ) ⁿ . Nous effectuons n essais de Bernoulli statistiquement indépendants.
Si on dispose d'une liste de m adresses distinctes (m<=2 ¹⁶⁰ ), l'espace de recherche est alors réduit à 2 ¹⁶⁰ /m, la probabilité de trouver une collision après 1 essai devient m/2 ¹⁶⁰ et la probabilité de trouver une collision après n essais devient 1-(1-m/2 ¹⁶⁰ ) ⁿ .
Un exemple :
Nous disposons d'un matériel capable de générer 1GKey/s et nous disposons d'une liste d'entrée de 10 ⁶ adresses, le tableau suivant montre la probabilité de trouver une collision après un certain temps :

Temps	Probabilité
1 seconde	6.8e-34
1 minute	4e-32
1 heure	2.4e-30
1 jour	5.9e-29
1 an	2.1e-26
10 ans	2.1e-25
1000 ans	2.1e-23
Âge de la terre	8.64e-17
Âge de l'univers	2.8e-16 (beaucoup moins que gagner à la loterie)

Le calcul a été effectué à l'aide de ce calculateur de haute précision en ligne

Comme vous pouvez le constater, même avec un matériel concurrent, il est très peu probable que vous trouviez une collision. Le paradoxe de l'anniversaire ne s'applique pas dans ce contexte, il ne fonctionne que si l'on connaît déjà la clé publique (pas l'adresse, le hachage de la clé publique) que l'on veut trouver. Ce programme ne recherche pas les collisions entre les clés publiques. Il recherche uniquement les collisions avec des adresses portant un certain préfixe.

Compilation

Fenêtres

Installez le SDK CUDA et ouvrez VanitySearch.sln dans Visual C++ 2017.
Vous devrez peut-être réinitialiser la version de votre SDK Windows dans les propriétés du projet.
Dans Build->Configuration Manager, sélectionnez la configuration Release .
Construisez et profitez-en.

Remarque : La version actuelle a été compilée avec le SDK CUDA 10.0. Si vous disposez d'une version différente du SDK CUDA, vous devrez peut-être mettre à jour les chemins du SDK CUDA dans VanitySearch.vcxproj à l'aide d'un éditeur de texte. L'option nvcc actuelle est configurée pour une architecture commençant à la capacité 3.0. Pour le matériel plus ancien, ajoutez les capacités de calcul souhaitées à la liste dans les propriétés GPUEngine.cu, CUDA C/C++, Device, Code Generation.

Linux

Installez le SDK CUDA.
Installez l'ancien g++ (uniquement pour le SDK CUDA). En fonction de la version du SDK CUDA et de votre distribution Linux, vous devrez peut-être installer un ancien g++.
Installez gcc récent. VanitySearch doit être compilé et lié à un gcc récent (>=7). La version actuelle a été compilée avec gcc 7.3.0.
Modifiez le makefile et configurez le SDK CUDA et les chemins du compilateur appropriés pour nvcc. Ou transmettez-les en tant que variables pour make une invocation.
```
 CUDA       = /usr/local/cuda-8.0
CXXCUDA    = /usr/bin/g++-4.8
```
Vous pouvez saisir une liste d'architectures (reportez-vous à la documentation nvcc) si vous disposez de plusieurs GPU avec des architectures différentes.
Définissez CCAP sur la capacité de calcul souhaitée en fonction de votre matériel. Voir la section Docker pour en savoir plus. La capacité de calcul 2.0 (Fermi) est obsolète pour le récent SDK CUDA.
Accédez au répertoire VanitySearch.
Pour créer une version CPU uniquement (sans prise en charge de CUDA) :
```
$ make all
```
Pour construire avec CUDA :
```
$ make gpu=1 CCAP=2.0 all
```

Runnig VanitySearch (processeur Intel(R) Xeon(R), 8 cœurs, à 2,93 GHz, Quadro 600 (x2))

$ export LD_LIBRARY_PATH=/usr/local/cuda-8.0/lib64
$ ./VanitySearch -t 7 -gpu -gpuId 0,1 1TryMe
# VanitySearch v1.10
# Difficulty: 15318045009
# Search: 1TryMe [Compressed]
# Start Wed Mar 27 10:26:43 2019
# Base Key:C6718D8E50C1A5877DE3E52021C116F7598826873C61496BDB7CAD668CE3DCE5
# Number of CPU thread: 7
# GPU: GPU #1 Quadro 600 (2x48 cores) Grid(16x128)
# GPU: GPU #0 Quadro 600 (2x48 cores) Grid(16x128)
# 40.284 MK/s (GPU 27.520 MK/s) (2^31.84) [P 22.24%][50.00% in 00:02:47][0]
#
# Pub Addr: 1TryMeERTZK7RCTemSJB5SNb2WcKSx45p
# Priv (WIF): Ky9bMLDpb9o5rBwHtLaidREyA6NzLFkWJ19QjPDe2XDYJdmdUsRk
# Priv (HEX): 0x398E7271AF3E5A78821C1ADFDE3EE90760A6B65F72D856CFE455B1264350BCE8

Docker

Balises prises en charge

latest , cuda-ccap-6 , cuda-ccap-6.0 (cuda/Dockerfile)
cuda-ccap-5 , cuda-ccap-5.2 (cuda/Dockerfile)
cuda-ccap-2 , cuda-ccap-2.0 (cuda/ccap-2.0.Dockerfile)
cpu (processeur/fichier Docker)

Construction Docker

Les images Docker sont créées pour la version CPU uniquement et pour chaque version de capacité de calcul CUDA ( CCAP ) prise en charge. Généralement, les utilisateurs doivent choisir le dernier CCAP pris en charge par leur matériel et leur pilote. Le tableau de compatibilité est disponible sur Wikipédia ou sur la page Web officielle NVIDIA de votre produit.

Docker utilise des constructions en plusieurs étapes pour améliorer la taille de l'image finale. Des scripts sont fournis pour faciliter le processus de construction.

Lorsque vous créez vous-même, le nom complet de l'image (y compris les parties propriétaire/dépôt) peut être personnalisé via la variable d'environnement IMAGE_NAME . Par défaut, il s'agit simplement d' vanitysearch sans notre partie propriétaire. Des images prédéfinies sont disponibles sur le hub Docker de @ratijas.

Version Docker / CPU uniquement

Construisez et marquez l'image vanitysearch:cpu :

$ ./docker/cpu/build.sh

Construction Docker/GPU

Créez avec la prise en charge GPU « par défaut », qui pourrait ne pas convenir à votre système :

$ ./docker/cuda/build.sh

Créez avec une prise en charge GPU personnalisée :

$ env CCAP=5.2 CUDA=10.2 ./docker/cuda/build.sh

Quant aux utilisateurs de Docker-Compose, désolé, les GPU composés de Docker ne sont pas (encore) pris en charge sur une branche 3.x. Mais cela (espérons-le) va bientôt changer.

Exécution Docker

Remarque : l'image VanitySearch ne nécessite pas (et ne devrait pas non plus) nécessiter un accès au réseau. Pour garantir davantage qu'aucune donnée ne fuit du conteneur en cours d'exécution, transmettez toujours --network none à la commande docker run.

$ docker run -it --rm --gpus all --network none ratijas/vanitysearch:cuda-ccap-5.2 -gpu -c -stop 1docker
# VanitySearch v1.18
# Difficulty: 957377813
# Search: 1docker [Compressed, Case unsensitive] (Lookup size 3)
# Start Sat Jul 11 17:41:32 2020
# Base Key: B506F2C7CA8AA2E826F2947012CFF15D2E6CD3DA5C562E8252C9F755F2A4C5D3
# Number of CPU thread: 1
# GPU: GPU #0 GeForce GTX 970M (10x128 cores) Grid(80x128)
#
# PubAddress: 1DoCKeRXYyydeQy6xxpneqtDovXFarAwrE
# Priv (WIF): p2pkh:KzESATCZFmnH1RfwT5XbCF9dZSnDGTS8z61YjnQbgFiM7tXtcH73
# Priv (HEX): 0x59E27084C6252377A8B7AABB20AFD975060914B3747BD6392930BC5BE7A06565