✅ 🧑🏽 📵 Exploiter des bitcoins sur IBM 1401, un vétéran de 55 ans 🏹 📳 ⚔️

Inspiré par la publication de l'utilisateur mark_ablov« En utilisant du bitcoin avec du papier et un stylo », nous avons décidé que les lecteurs de hiktime seraient intéressés par les autres idées folles que l'auteur du message original, Ken Shirriff, avait réussi à réaliser.

Le mainframe IBM des années 60 du siècle dernier peut-il être utilisé pour extraire des bitcoins? J'ai décidé de vérifier cette idée apparemment folle. J'ai injecté l'algorithme de hachage Bitcoin dans du code assembleur pour IBM 1401 et l'ai testé en pratique en l'exécutant sur un modèle réalisable de cet ancien ordinateur central.

La carte avec laquelle les hachages SHA-256 ont été calculés sur le mainframe IBM 1401. Une impression est visible derrière la carte, montrant l'entrée de l'algorithme et le hachage résultant

Il s'est avéré qu'en utilisant cet ordinateur, vous pouvez extraire, mais ce processus prendra tellement de temps que même toute la durée de vie de l'Univers peut ne pas être suffisante pour réussir l'extraction d'un bloc.

Alors que le matériel moderne vous permet de calculer des milliards de hachages par seconde, l'ordinateur 1401 consacre 80 secondes chacun à calculer un seul hachage. Les progrès des performances informatiques au cours des dernières décennies sont évidents, ce qui est clairement décrit par la loi de Gordon Moore.

Les cartes perforées qui ont participé à l'expérience, ainsi que l'impression SHA-256 avec une imprimante linéaire sont illustrées sur la photo ci-dessus (la première carte perforée ne sert qu'à la beauté - il n'a pas été facile de percer ce modèle). Notez que la deuxième ligne se termine par un groupe de zéros; cela signifie un hachage réussi.

Principe de minage de Bitcoin

Récemment, la monnaie électronique Bitcoin (Bitcoin), que les internautes peuvent transférer entre eux, a été très populaire. Pour comprendre l'essence du travail de cette crypto-monnaie, le système Bitcoin peut être présenté sous la forme d'une sorte de journal comptable, qui stocke des enregistrements sur le propriétaire des pièces numériques (bitcoins) et le nombre de pièces dont il dispose. Les membres Bitcoin peuvent se transférer des pièces numériques entre eux.

Il convient de noter que le système Bitcoin est décentralisé: il ne dispose pas d'un seul serveur de régulation qui surveillerait l'avancement des transactions. Au lieu de cela, les enregistrements sont envoyés sur un réseau distribué à partir de milliers d'ordinateurs sur Internet.

La difficulté est qu'un tel système distribué doit en quelque sorte garantir que tous les utilisateurs sont d'accord sur les enregistrements. Autrement dit, les utilisateurs consciencieux doivent confirmer la validité de la transaction, l'approuver, malgré la présence possible de fraudeurs et de réseaux lents. La solution à ce problème a été la soi-disant «exploitation minière». Environ toutes les 10 minutes pendant le processus d'extraction, un bloc de transactions sortantes est confirmé, par conséquent, il est considéré comme officiellement confirmé.

Le processus d'extraction, basé sur une cryptographie fiable, est extrêmement compliqué, donc personne ne peut contrôler les transactions qui sont extraites. En particulier, l'idée clé du système Bitcoin est que le résultat du travail est difficile et difficile, mais facile à vérifier. Il s'agit de la technologie dite de «preuve de travail».

Le processus d'extraction de blocs nécessite un énorme coût de calcul. Cependant, une fois le blocage confirmé, les utilisateurs d'égal à égal peuvent facilement vérifier sa validité. La complexité de l'exploitation minière empêche l'utilisation frauduleuse de Bitcoin, et la facilité de vérifier la validité du bloc permet aux utilisateurs d'avoir confiance en la validité des transactions.

Un effet secondaire de l'exploitation minière est l'ajout de nouveaux bitcoins au système. Actuellement, tous ceux qui confirment le bloc reçoivent 25 bitcoins générés pour cela (maintenant le coût de ce nombre de pièces virtuelles en termes monétaires traditionnels est d'environ 6 mille dollars américains). Cet encouragement encourage les mineurs à travailler dur et à dépenser leurs ressources pour l'exploitation minière. Étant donné la possibilité de recevoir 6 000 dollars toutes les 10 minutes, l'exploitation minière semble être une véritable «mine d'or», encourageant les utilisateurs à dépenser des sommes importantes en matériel pour l'exploitation minière.

L'imprimante en ligne et l'ordinateur central IBM 1401 sont présentés au Computer History Museum. Cet ordinateur exécutait mon programme. La console est située en haut à gauche. Les panneaux rectangulaires foncés de l'ordinateur sont les «portes» des racks inclinables, offrant un accès pour l'entretien.

Le processus d'extraction est extrêmement compliqué, mais le résultat est très facile à vérifier. Le minage de Bitcoin utilise la cryptographie avec une fonction de hachage appelée double SHA-256. Le hachage prend un bloc de données à l'entrée et le réduit à une valeur de hachage inférieure (dans ce cas, 256 bits).

L'algorithme de hachage cryptographique ne vous permettra pas d'obtenir la valeur de hachage souhaitée sans avoir à trier la masse de données à l'entrée. Cependant, après avoir trouvé une entrée qui donne la valeur souhaitée, tout le monde peut facilement vérifier le hachage. Par conséquent, le hachage cryptographique est un bon moyen d'implémenter des bitcoins de «preuve de travail».

Plus en détail, afin de restreindre un bloc, vous devez d'abord collecter de nouvelles transactions dans un bloc. Ensuite, vous devez hacher le bloc pour obtenir (essentiellement au hasard) la valeur de hachage du bloc. Si la valeur de hachage commence par 16 zéros, le bloc est considéré comme confirmé avec succès et envoyé au réseau Bitcoin. La plupart du temps, le hachage échoue, vous modifiez donc légèrement le bloc et réessayez encore et encore, après plus d'un milliard d'opérations de calcul. Toutes les 10 minutes environ, quelqu'un réussit à confirmer le blocage et le processus recommence. Cela rappelle une loterie à laquelle les mineurs participent, faisant une tentative après une tentative, jusqu'à ce que quelqu'un devienne un «gagnant». La complexité du processus de hachage est difficile à visualiser: il est plus facile de trouver un grain de sable dans tout le sable de la Terre que de trouver une valeur de hachage valide.Pour rechercher de telles valeurs de hachage, les mineurs utilisent des centres de données équipés de matériel spécial pour l'extraction.

Je simplifie délibérément bon nombre des explications de cet article. Si vous souhaitez en savoir plus sur le système Bitcoin et l'exploitation minière, je vous conseille d'étudier mes articles La difficile expérience de l'extraction de bitcoins et les dures leçons de l'extraction de bitcoin .

Algorithme de hachage Bitcoin SHA-256

Maintenant, je vais regarder la fonction de hachage utilisée par Bitcoin, qui est basée sur une fonction de hachage cryptographique standard appelée SHA-256. Le système Bitcoin utilise un «double SHA-256». Cela signifie que la fonction SHA-256 est exécutée deux fois. L'algorithme SHA-256 est si simple que vous pouvez l'exécuter littéralement en utilisant uniquement un crayon et du papier , et l'algorithme vous permet de mélanger les données de manière imprévisible. L'algorithme accepte des blocs de 64 octets en entrée, traite les données cryptographiquement et produit 256 bits (32 octets) de données cryptées. L'algorithme utilise un tour, qui est répété 64 fois. L'illustration ci-dessous montre un tour de l'algorithme, qui prend huit blocs de 4 octets, A à H, effectue plusieurs opérations et produit de nouvelles valeurs pour A à N.

Round SHA-256, utilisant Wikipedia comme exemple , par kockmeyer, CC BY-SA 3.0

Les blocs bleu foncé mélangent les bits de manière non linéaire, ce qui est difficile pour l'analyse cryptographique. (Si vous parvenez à trouver un moyen mathématiquement plus rapide d'obtenir des hachages réussis, vous pouvez contrôler l'extraction des bitcoins). La cellule "select" Ch sélectionne les bits de F ou G, en fonction de la valeur de l'entrée E. Les cellules Σ "sum" font tourner les bits A (ou E) générant trois versions décalées cycliques, puis les additionnent ensemble modulo 2.

La cellule majoritaire Ma vérifie les bits à chaque position de A, B et C et sélectionne 0 ou 1, selon la valeur qui est majoritaire. Les globules rouges effectuent des ajouts 32 bits, générant de nouvelles valeurs pour A et E. L'entrée Wt est basée sur une entrée légèrement traitée. (C'est là que le bloc d'entrée est introduit dans l'algorithme.) L'entrée Kt est une constante définie pour chaque tour.

Selon l'illustration ci-dessus, seuls A et E sont modifiés par tour. Les valeurs restantes sont ignorées telles quelles. L'ancienne valeur de A devient la nouvelle valeur de B, l'ancienne valeur de B devient la nouvelle valeur de C, etc. Bien que chaque tour de SHA-256 modifie légèrement les données, après 64 tours, les données d'entrée sont complètement mélangées, donnant une valeur de hachage imprévisible.

Ibm 1401

J'ai décidé d'exécuter cet algorithme sur le mainframe IBM 1401. Cet ordinateur est apparu en 1959 et au milieu des années 60 est devenu l'ordinateur le plus vendu - à cette époque, plus de 10 000 machines étaient activement utilisées. L'ordinateur 1401 n'était pas un ordinateur très puissant, même pour 1960. Cependant, il était abordable pour les moyennes entreprises qui auparavant ne pouvaient pas se permettre d'avoir un ordinateur, car il pouvait être loué pour peu d'argent - 2 500 $ par mois.

L'IBM 1401 n'utilisait pas de puces de silicium. De plus, dans cet ordinateur, il n'y avait pas de puces du tout. Ses transistors étaient construits sur des semi-conducteurs, des cristaux de germanium, qui étaient utilisés avant le silicium. Des transistors, ainsi que d'autres composants, ont été installés sur des cartes de la taille de cartes à jouer appelées cartes SMS. L'ordinateur comportait des milliers de ces cartes, qui ont été installées sous la forme de racks appelés «portes». L'IBM 1401 possède vingt «portes» de ce type qui ont été proposées pour la maintenance informatique. Dans l'illustration ci-dessus, une porte ouverte est visible, donnant accès aux micropuces et aux câbles.

L'illustration montre un rack ouvert (appelé «porte») de l'unité centrale IBM 1401. La photo montre des cartes SMS connectées au circuit. Ce rack contient des lecteurs de bande

Le principe de fonctionnement d'un tel ordinateur était très différent des PC modernes. Cet ordinateur n'utilisait pas des octets 8 bits, mais des caractères 6 bits basés sur un nombre décimal codé binaire (BCD). Étant donné que cet ordinateur était une machine à calculer pour résoudre les problèmes économiques, il utilisait l'arithmétique décimale plutôt que binaire, et chaque caractère dans la mémoire avait une valeur numérique de 0 à 9. La mémoire de l'ordinateur sur des noyaux magnétiques contenait 4000 caractères. Un module d'extension mémoire de la taille d'un lave-vaisselle a augmenté la capacité mémoire de 12 000 caractères. La saisie des données dans l'ordinateur a été effectuée à l'aide de cartes perforées. Le lecteur de cartes lit les données et les programmes des cartes. Les données de sortie ont été imprimées par une imprimante à grande vitesse ou perforées sur des cartes.

Musée d'histoire de l' ordinateur Musée d'histoire de l' ordinateurà Mountain View, il dispose de deux ordinateurs centraux IBM 1401. Sur l'un d'eux, j'ai exécuté le code de hachage SHA-256. Je parle plus d'IBM 1401 dans mon article Fractals sur IBM 1401
.

Exécution de SHA-256 sur un IBM 1401

L'ordinateur IBM 1401 est certainement la pire de toutes les machines qui pourraient être choisies pour exécuter l'algorithme de hachage SHA-256. Pour fonctionner efficacement, cet algorithme nécessite des machines capables d'effectuer des opérations binaires sur des mots 32 bits. Malheureusement, IBM 1401 ne prend en charge ni les mots ni les octets 32 bits. Cet ordinateur fonctionne avec des caractères 6 bits et n'autorise pas les opérations sur les bits. De plus, au lieu de binaire, l'arithmétique décimale a été utilisée. Par conséquent, l'algorithme sur l'ordinateur 1401 sera lent et incommode pour l'utilisateur.

J'ai fini par utiliser un caractère par bit. La valeur 32 bits a été stockée sous forme de 32 caractères, soit «0» ou «1». Mon code devait effectuer des opérations au niveau du bit, des multiplications et des ajouts caractère par caractère, vérifier chaque caractère et décider quoi en faire. Comme vous vous en doutez, l'exécution du code a pris beaucoup de temps.

Ensuite, je présente le code assembleur que j'ai écrit. En général, le principe du code est décrit dans les commentaires. À la fin du code, il y a une table de constantes nécessaires pour l'algorithme SHA-256 sous forme hexadécimale. Étant donné que l'ordinateur 1401 ne prend pas en charge le format hexadécimal, j'ai dû écrire mes propres routines pour convertir les formats hexadécimal et binaire. Dans cet article, je n'expliquerai pas le code assembleur pour IBM 1401, je souligne seulement qu'il est très différent de ce que les ordinateurs modernes utilisent. Ce code n'appelle pas de sous-programmes et ne renvoie pas de résultats. En raison de l'absence de registres à usage général, les opérations sont effectuées en mémoire.

Recherchez le code sous le spoiler:

Texte masqué

job  bitcoin
     * SHA-256 hash
     * Ken Shirriff  http://righto.com
               ctl  6641

               org  087
     X1        dcw  @000@
               org  092
     X2        dcw  @000@
               org  097
     X3        dcw  @000@
     
               org  333
     start     cs   299
               r
               sw   001
               lca  064, input0
               mcw  064, 264
               w
     * Initialize word marks on storage
               mcw  +s0, x3

     wmloop    sw   0&x3  
               ma   @032@, x3
               c    +h7+32, x3
               bu   wmloop
     
               mcw  +input-127, x3      * Put input into warr[0] to warr[15]
               mcw  +warr, x1
               mcw  @128@, tobinc
               b    tobin
     
     * Compute message schedule array w[0..63]
  
               mcw  @16@, i
     * i is word index 16-63   
     * x1 is start of warr[i-16], i.e. bit 0 (bit 0 on left, bit 31 on right)   
               mcw  +warr, x1
     wloop     c    @64@, i
               be   wloopd
     
     * Compute s0
               mcw  +s0, x2
               za   +0, 31&x2               * Zero s0
     * Add w[i-15] rightrotate 7
               sw   7&x2               * Wordmark at bit 7 (from left) of s0
               a    56&x1, 31&x2       * Right shifted: 32+31-7 = bit 24 of w[i-15], 31 = end of s0
               a    63&x1, 6&x2        * Wrapped: 32+31 = end of w[i-15], 7-1 = bit 6 of s0   
               cw   7&x2               * Clear wordmark
     * Add w[i-15] rightrotate 18
               sw   18&x2              * Wordmark at bit 18 (from left) of s0
               a    45&x1, 31&x2       * Right shifted: 32+31-18 = bit 13 of w[i-15], 31 = end of s0
               a    63&x1, 17&x2       * Wrapped: 32+31 = end of w[i-15], 18-1 = bit 17 of s0   
               cw   18&x2              * Clear wordmark
     * Add w[i-15] rightshift 3
               sw   3&x2               * Wordmark at bit 3 (from left) of s0
               a    60&x1, 31&x2       * Right shifted: 32+31-3 = bit 28 of w[i-15], 31 = end of s0
               cw   3&x2               * Clear wordmark
     * Convert sum to xor
               mcw  x1, x1tmp
               mcw  +s0+31, x1         * x1 = right end of s0
               mcw  @032@, x2          * Process 32 bits
               b    xor
               sw   s0                 * Restore wordmark cleared by xor
     
               mcw  x1tmp, x1
     
     * Compute s1         
               mcw  +s1, x2
               za   +0, 31&x2               * Zero s1
     * Add w[i-2] rightrotate 17
               sw   17&x2              * Wordmark at bit 17 (from left) of s1
               a    462&x1, 31&x2      * Right shifted: 14*32+31-17 = bit 14 of w[i-2], 31 = end of s1
               a    479&x1, 16&x2      * Wrapped: 14*32+31 = end of w[i-2], 17-1 = bit 16 of s1   
               cw   17&x2              * Clear wordmark
     * Add w[i-2] rightrotate 19
               sw   19&x2              * Wordmark at bit 19 (from left) of s1
               a    460&x1, 31&x2      * Right shifted: 14*32+31-19 = bit 12 of w[i-2], 31 = end of s1
               a    479&x1, 18&x2      * Wrapped: 14*32+31 = end of w[i-2], 19-1 = bit 18 of s1  
               cw   19&x2              * Clear wordmark
     * Add w[i-2] rightshift 10
               sw   10&x2              * Wordmark at bit 10 (from left) of s1
               a    469&x1, 31&x2      * Right shifted: 14*32+31-10 = bit 21 of w[i-2], 31 = end of s1
               cw   10&x2              * Clear wordmark
     * Convert sum to xor
               mcw  +s1+31, x1         * x1 = right end of s1
               mcw  @032@, x2          * Process 32 bits
               b    xor
               sw   s1                 * Restore wordmark cleared by xor
     
     * Compute w[i] := w[i-16] + s0 + w[i-7] + s1
               mcw  x1tmp, x1
               a    s1+31, s0+31       * Add s1 to s0
               a    31&x1, s0+31       * Add w[i-16] to s0
               a    319&x1, s0+31      * Add 9*32+31 = w[i-7] to s0
     * Convert bit sum to 32-bit sum
               mcw  +s0+31, x1         * x1 = right end of s0
               mcw  @032@, x2          * Process 32 bits
               b    sum
               sw   s0                 * Restore wordmark cleared by sum
     

     
               mcw  x1tmp, x1
               mcw  s0+31, 543&x1      * Move s0 to w[i]
       
              
               ma   @032@, x1
               a    +1, i
               mz   @0@, i
               b    wloop
     
     x1tmp     dcw  #5
     

     * Initialize: Copy hex h0init-h7init into binary h0-h7
     wloopd    mcw  +h0init-7, x3
               mcw  +h0, x1
               mcw  @064@, tobinc       * 8*8 hex digits
               b    tobin
     
     
     * Initialize a-h from h0-h7
               mcw  @000@, x1
     ilp       mcw  h0+31&x1, a+31&x1
               ma   @032@, x1
               c    x1, @256@
               bu   ilp
     
               mcw  @000@, bitidx      * bitidx = i*32 = bit index
               mcw  @000@, kidx        * kidx = i*8 = key index
                

     * Compute s1 from e        
     mainlp    mcw  +e, x1
               mcw  +s1, x2
               za   +0, 31&x2               * Zero s1
     * Add e rightrotate 6
               sw   6&x2               * Wordmark at bit 6 (from left) of s1
               a    25&x1, 31&x2       * Right shifted: 31-6 = bit 25 of e, 31 = end of s1
               a    31&x1, 5&x2        * Wrapped: 31 = end of e, 6-1 = bit 5 of s1   
               cw   6&x2               * Clear wordmark
     * Add e rightrotate 11
               sw   11&x2              * Wordmark at bit 11 (from left) of s1
               a    20&x1, 31&x2       * Right shifted: 31-11 = bit 20 of e, 31 = end of s1
               a    31&x1, 10&x2       * Wrapped: 31 = end of e, 11-1 = bit 10 of s1   
               cw   11&x2              * Clear wordmark
     * Add e rightrotate 25
               sw   25&x2              * Wordmark at bit 25 (from left) of s1
               a    6&x1, 31&x2        * Right shifted: 31-25 = bit 6 of e, 31 = end of s1
               a    31&x1, 24&x2       * Wrapped: 31 = end of e, 25-1 = bit 24 of s1   
               cw   25&x2              * Clear wordmark
     * Convert sum to xor
               mcw  +s1+31, x1         * x1 = right end of s1
               mcw  @032@, x2          * Process 32 bits
               b    xor
               sw   s1                 * Restore wordmark cleared by xor

     * Compute ch: choose function
               mcw  @000@, x1          * x1 is index from 0 to 31
     chl       c    e&x1, @0@
               be   chzero
               mn   f&x1, ch&x1        * for 1, select f bit
               b    chincr
     chzero    mn   g&x1, ch&x1        * for 0, select g bit
     chincr    a    +1, x1
               mz   @0@, x1
               c    @032@, x1
               bu   chl

     * Compute temp1: k[i] + h + S1 + ch + w[i]
               cs   299
               mcw  +k-7, x3            * Convert k[i] to binary in temp1
               ma   kidx, x3
               mcw  +temp1, x1
               mcw  @008@, tobinc       * 8 hex digits
               b    tobin
               mcw  @237@, x3
               mcw  +temp1, x1
               mcw  @008@, tobinc
               b    tohex
               a    h+31, temp1+31     * +h
               a    s1+31, temp1+31    * +s1
               a    ch+31, temp1+31    * +ch
               mcw  bitidx, x1
               a    warr+31&x1, temp1+31         * + w[i]
     * Convert bit sum to 32-bit sum
               mcw  +temp1+31, x1      * x1 = right end of temp1
               b    sum
  

     * Compute s0 from a
               mcw  +a, x1
               mcw  +s0, x2
               za   +0, 31&x2               * Zero s0
     * Add a rightrotate 2
               sw   2&x2               * Wordmark at bit 2 (from left) of s0
               a    29&x1, 31&x2       * Right shifted: 31-2 = bit 29 of a, 31 = end of s0
               a    31&x1, 1&x2        * Wrapped: 31 = end of a, 2-1 = bit 1 of s0   
               cw   2&x2               * Clear wordmark
     * Add a rightrotate 13
               sw   13&x2              * Wordmark at bit 13 (from left) of s0
               a    18&x1, 31&x2       * Right shifted: 31-13 = bit 18 of a, 31 = end of s0
               a    31&x1, 12&x2       * Wrapped: 31 = end of a, 13-1 = bit 12 of s0   
               cw   13&x2              * Clear wordmark
     * Add a rightrotate 22
               sw   22&x2              * Wordmark at bit 22 (from left) of s0
               a    9&x1, 31&x2        * Right shifted: 31-22 = bit 9 of a, 31 = end of s0
               a    31&x1, 21&x2       * Wrapped: 31 = end of a, 22-1 = bit 21 of s0   
               cw   22&x2              * Clear wordmark
     * Convert sum to xor
               mcw  +s0+31, x1         * x1 = right end of s0
               mcw  @032@, x2          * Process 32 bits
               b    xor
               sw   s0                 * Restore wordmark cleared by xor

     * Compute maj(a, b, c): majority function
               za   +0, maj+31
               a    a+31, maj+31
               a    b+31, maj+31
               a    c+31, maj+31
               mz   @0@, maj+31
               mcw  @000@, x1          * x1 is index from 0 to 31
     mjl       c    maj&x1, @2@
               bh   mjzero
               mn   @1@, maj&x1       * majority of the 3 bits is 1
               b    mjincr
     mjzero    mn   @0@, maj&x1       * majority of the 3 bits is 0
     mjincr    a    +1, x1
               mz   @0@, x1
               c    @032@, x1
               bu   mjl

     * Compute temp2: S0 + maj
               za   +0, temp2+31
               a    s0+31, temp2+31
               a    maj+31, temp2+31
     * Convert bit sum to 32-bit sum
               mcw  +temp2+31, x1      * x1 = right end of temp1
               b    sum
     
               mcw  g+31, h+31         * h := g
               mcw  f+31, g+31         * g := f
               mcw  e+31, f+31         * f := e
               za   +0, e+31           * e := d + temp1
               a    d+31, e+31
               a    temp1+31, e+31
               mcw  +e+31, x1          * Convert sum to 32-bit sum
               b    sum
               mcw  c+31, d+31         * d := c
               mcw  b+31, c+31         * c := b
               mcw  a+31, b+31         * b := a
               za   +0, a+31           * a := temp1 + temp2
               a    temp1+31, a+31
               a    temp2+31, a+31
               mcw  +a+31, x1          * Convert sum to 32-bit sum
               b    sum

               a    @8@, kidx          * Increment kidx by 8 chars
               mz   @0@, kidx
               ma   @032@, bitidx      * Increment bitidx by 32 bits
               c    @!48@, bitidx      * Compare to 2048
               bu   mainlp

     * Add a-h to h0-h7
               cs   299
               mcw  @00000@, x1tmp  
     add1      mcw  x1tmp, x1
               a    a+31&x1, h0+31&x1
               ma   +h0+31, x1          * Convert sum to 32-bit sum
               b    sum     
               ma   @032@, x1tmp
               c    @00256@, x1tmp
               bu   add1
               mcw  @201@, x3
               mcw  +h0, x1
               mcw  @064@, tobinc
               b    tohex
               w
               mcw  280, 180
               p
               p

     finis     h
               b    finis

      
     * Converts sum of bits to xor
     * X1 is right end of word
     * X2 is bit count    
     * Note: clears word marks
     xor       sbr  xorx&3
     xorl      c    @000@, x2
               be   xorx
     xorfix    mz   @0@, 0&x1          * Clear zone
               c    0&x1, @2@
               bh   xorok
               sw   0&x1               * Subtract 2 and loop
               s    +2, 0&x1
               cw   0&x1
               b    xorfix
     xorok     ma   @I9I@, x1         * x1 -= 1
               s    +1, x2             * x2 -= 1
               mz   @0@, x2
               b    xorl               * loop
     
     xorx      b    @000@
     
     * Converts sum of bits to sum (i.e. propagate carries if digit > 1)
     * X1 is right end of word
     * Ends at word mark
     sum       sbr  sumx&3
     suml      mz   @0@, 0&x1          * Clear zone
               c    0&x1, @2@          * If digit is <2, then ok
               bh   sumok
               s    +2, 0&x1           * Subtract 2 from digit
               bwz  suml, 0&x1, 1      * Skip carry if at wordmark
               a    @1@, 15999&x1      * Add 1 to previous position
               b    suml               * Loop
     sumok     bwz  sumx,0&x1,1        * Quit if at wordmark
               ma   @I9I@, x1          * x1 -= 1
               b    suml               * loop
     sumx      b    @000@              * return
     
     * Converts binary to string of hex digits
     * X1 points to start (left) of binary
     * X3 points to start (left) of hex buffer
     * X1, X2, X3 destroyed
     * tobinc holds count (# of hex digits)
     tohex     sbr  tohexx&3
     tohexl    c    @000@, tobinc      * check counter
               be   tohexx
               s    @1@, tobinc        * decrement counter
               mz   @0@, tobinc
               b    tohex4
               mcw  hexchr, 0&x3
               ma   @004@, X1
               ma   @001@, X3
               b    tohexl             * loop
     tohexx    b    @000@ 
     

     
     * X1 points to 4 bits
     * Convert to hex char and write into hexchr
     * X2 destroyed

     tohex4    sbr  tohx4x&3
               mcw  @000@, x2
               c    3&X1, @1@
               bu   tohx1
               a    +1, x2
     tohx1     c    2&X1, @1@
               bu   tohx2
               a    +2, x2
     tohx2     c    1&x1, @1@
               bu   tohx4
               a    +4, x2
     tohx4     c    0&x1, @1@
               bu   tohx8
               a    +8, x2
     tohx8     mz   @0@, x2
               mcw  hextab-15&x2, hexchr
     tohx4x    b    @000@
     
     * Converts string of hex digits to binary
     * X3 points to start (left) of hex digits
     * X1 points to start (left) of binary digits
     * tobinc holds count (# of hex digits)
     * X1, X3 destroyed
     tobin     sbr  tobinx&3
     tobinl    c    @000@, tobinc      * check counter
               be   tobinx
               s    @1@, tobinc        * decrement counter
               mz   @0@, tobinc
               mcw  0&X3, hexchr
               b    tobin4             * convert 1 char
               ma   @004@, X1
               ma   @001@, X3
               b    tobinl             * loop
     tobinx    b    @000@
               
     
     tobinc    dcw  @000@
     * Convert hex digit to binary
     * Digit in hexchr (destroyed)
     * Bits written to x1, ..., x1+3
     tobin4    sbr  tobn4x&3
               mcw  @0000@, 3+x1   * Start with zero bits
               bwz  norm,hexchr,2  * Branch if no zone
              
               mcw  @1@, 0&X1
               a    @1@, hexchr    * Convert letter to value: A (1) -> 2, F (6) -> 7
               mz   @0@, hexchr
               b    tob4
     norm      c    @8@, hexchr
               bl   tob4
               mcw  @1@, 0&X1
               s    @8@, hexchr
               mz   @0@, hexchr
     tob4      c    @4@, hexchr
               bl   tob2
               mcw  @1@, 1&X1
               s    @4@, hexchr
               mz   @0@, hexchr
     tob2      c    @2@, hexchr
               bl   tob1
               mcw  @1@, 2&X1
               s    @2@, hexchr
               mz   @0@, hexchr
     tob1      c    @1@, hexchr
               bl   tobn4x
               mcw  @1@, 3&X1
     tobn4x    b    @000@          


     
     * Message schedule array is 64 entries of 32 bits = 2048 bits.
               org  3000
     warr      equ  3000
     
     s0        equ  warr+2047                *32 bits
     s1        equ  s0+32 
     ch        equ  s1+32              *32 bits

     temp1     equ  ch+32               *32 bits
     
     temp2     equ  temp1+32                *32 bits
     
     maj       equ  temp2+32                *32 bits
     
     a         equ  maj+32
     b         equ  a+32
     c         equ  b+32
     d         equ  c+32
     e         equ  d+32
     f         equ  e+32
     g         equ  f+32
     h         equ  g+32
     h0        equ  h+32
     h1        equ  h0+32
     h2        equ  h1+32
     h3        equ  h2+32
     h4        equ  h3+32
     h5        equ  h4+32
     h6        equ  h5+32
     h7        equ  h6+32
               org  h7+32
 
     hexchr    dcw  @0@
     hextab    dcw  @0123456789abcdef@    
     i         dcw  @00@               * Loop counter for w computation
     bitidx    dcw  #3
     kidx      dcw  #3         
     
     * 64 round constants for SHA-256
     k         dcw  @428a2f98@
               dcw  @71374491@
               dcw  @b5c0fbcf@
               dcw  @e9b5dba5@
               dcw  @3956c25b@
               dcw  @59f111f1@
               dcw  @923f82a4@
               dcw  @ab1c5ed5@
               dcw  @d807aa98@
               dcw  @12835b01@
               dcw  @243185be@
               dcw  @550c7dc3@
               dcw  @72be5d74@
               dcw  @80deb1fe@
               dcw  @9bdc06a7@
               dcw  @c19bf174@
               dcw  @e49b69c1@
               dcw  @efbe4786@
               dcw  @0fc19dc6@
               dcw  @240ca1cc@
               dcw  @2de92c6f@
               dcw  @4a7484aa@
               dcw  @5cb0a9dc@
               dcw  @76f988da@
               dcw  @983e5152@
               dcw  @a831c66d@
               dcw  @b00327c8@
               dcw  @bf597fc7@
               dcw  @c6e00bf3@
               dcw  @d5a79147@
               dcw  @06ca6351@
               dcw  @14292967@
               dcw  @27b70a85@
               dcw  @2e1b2138@
               dcw  @4d2c6dfc@
               dcw  @53380d13@
               dcw  @650a7354@
               dcw  @766a0abb@
               dcw  @81c2c92e@
               dcw  @92722c85@
               dcw  @a2bfe8a1@
               dcw  @a81a664b@
               dcw  @c24b8b70@
               dcw  @c76c51a3@
               dcw  @d192e819@
               dcw  @d6990624@
               dcw  @f40e3585@
               dcw  @106aa070@
               dcw  @19a4c116@
               dcw  @1e376c08@
               dcw  @2748774c@
               dcw  @34b0bcb5@
               dcw  @391c0cb3@
               dcw  @4ed8aa4a@
               dcw  @5b9cca4f@
               dcw  @682e6ff3@
               dcw  @748f82ee@
               dcw  @78a5636f@
               dcw  @84c87814@
               dcw  @8cc70208@
               dcw  @90befffa@
               dcw  @a4506ceb@
               dcw  @bef9a3f7@
               dcw  @c67178f2@
     * 8 initial hash values for SHA-256
     h0init    dcw  @6a09e667@
     h1init    dcw  @bb67ae85@
     h2init    dcw  @3c6ef372@
     h3init    dcw  @a54ff53a@
     h4init    dcw  @510e527f@
     h5init    dcw  @9b05688c@
     h6init    dcw  @1f83d9ab@
     h7init    dcw  @5be0cd19@


     input0    equ  h7init+64
               org  h7init+65

               dc   @80000000000000000000000000000000@
     input     dc   @00000000000000000000000000000100@      * 512 bits with the mostly-zero padding

               end  start

Le programme exécutable a été appliqué à 85 cartes perforées (vous les avez déjà vues au début de l'article). J'ai également fait une carte perforée avec un algorithme de hachage. Afin d'exécuter le programme, j'ai dû charger la carte perforée dans le lecteur de carte et cliquer sur le bouton "Charger". Le lecteur de cartes a traité 800 cartes par minute. Ainsi, il n'a fallu que quelques secondes pour télécharger le programme. Pendant l'exécution du programme, la console d'ordinateur (voir l'illustration ci-dessous) a clignoté fébrilement pendant 40 secondes. Enfin, l'imprimante a imprimé pour moi le hachage final (vous avez également vu l'impression au début de l'article), et les résultats ont été appliqués à une nouvelle carte perforée. Étant donné que l'exploitation minière Bitcoin utilise le double hachage SHA-256, le processus de hachage minier a pris deux fois plus de temps (80 secondes).

Travail acharné de la console IBM 1401 lors du calcul du hachage SHA-256

Comparaison des performances

L'ordinateur IBM 1401 peut calculer le double hachage SHA-256 en 80 secondes. Pour effectuer cette tâche, l'ordinateur consomme environ 3 000 watts, à peu près la même chose qu'une cuisinière électrique ou une sécheuse. À un moment donné, le système de base IBM 1401 a coûté 125 600 $. Dans la réalité de 2015, cela représente environ un million de dollars américains. Dans le même temps, vous pouvez maintenant acheter un lecteur flash USB pour l'exploitation minière pour 50 $, qui dispose d'un circuit intégré spécialisé (mineur ASIC USB). Ce mineur USB effectue 3,6 milliards de hachages par seconde, tout en consommant environ 4 watts.
Ces indicateurs de performance importants sont dus à plusieurs facteurs: une forte augmentation des performances informatiques au cours des 50 dernières années selon la loi de Moore, une perte de performances associée à l'utilisation de l'arithmétique décimale dans les ordinateurs pour résoudre des problèmes commerciaux, qui était occupé à calculer un code de hachage binaire, ainsi qu'un gain de vitesse avec côtés du matériel d'extraction de bitcoin traditionnel.

Résumer. Pour exploiter le bloc, compte tenu des exigences actuelles de ce processus, l'ordinateur IBM 1401 aura besoin d'environ 5 x 10 ^ 14 ans (ce qui représente 40 000 fois l'âge actuel de l'Univers). Le coût de l'électricité consommée sera d'environ 10 ^ 18 dollars américains. En conséquence, vous recevrez 25 bitcoins, dont la valeur monétaire sera d'environ 6 000 dollars américains. Ainsi, l'extraction de bitcoins sur le mainframe IBM 1401 ne peut pas être considérée comme une entreprise rentable. Les photographies ci-dessous comparent les puces informatiques des années 60 du siècle dernier et les options modernes, démontrant clairement les progrès technologiques.

: SMS , IBM 1401. . . : Bitfury ASIC 2-3 . : zeptobars (CC BY 3.0)

Vous pouvez décider que les bitcoins sont incompatibles avec la technologie des années 60 du siècle dernier en raison du manque de capacité à transmettre des données sur le réseau. Quelqu'un devra-t-il envoyer des cartes perforées avec une chaîne de blocs à d'autres ordinateurs? La communication entre les ordinateurs via le réseau est apparue il y a longtemps. Dès 1941, IBM a pris en charge le soi-disant processus de traitement des données télémétriques (à distance). Dans les années 60, IBM 1401 pouvait être connecté à un périphérique de transmission de données IBM 1009 ( IBM 1009 Data Transmission Unit) - un modem de la taille d'un lave-vaisselle, qui permettait aux ordinateurs d'échanger des données entre eux sur une ligne téléphonique jusqu'à 300 caractères par seconde. Autrement dit, la construction d'un réseau Bitcoin basé sur les technologies des années 60 du siècle dernier est tout à fait possible. Malheureusement, je n'ai pas pu obtenir d'équipement pour le télétraitement des données et tester cette théorie.

Le dispositif de transfert de données IBM 1009. Un modem de la taille d'un lave-vaisselle est apparu en 1960. Avec lui, il était possible de transmettre jusqu'à 300 caractères par seconde sur une ligne téléphonique. Source de la photo: Introduction aux systèmes de traitement de données IBM) .

résultats

L'utilisation de SHA-256 dans le langage d'assemblage de l'ancien ordinateur central est devenue une expérience difficile mais intéressante. Je m'attendais à de meilleures performances (même par rapport à mon set Mandelbrot en 12 minutes ). L'arithmétique décimale d'un ordinateur commercial n'est pas la meilleure option pour un algorithme binaire comme SHA-256. Cependant, l'algorithme d'exploration de Bitcoin peut être exécuté même sur un ordinateur sans circuits intégrés. Par conséquent, si soudainement un certain effondrement temporaire me porte à 1960, je peux construire un réseau Bitcoin.

Le Mountain View Museum of Computer History montre les IBM 1401 en cours d'exécution les mercredis et samedis. Si vous vous trouvez à proximité, vous devriez certainement y jeter un œil en consultant les horairestravail. Et si vous parlez au personnel du musée qui fait la démonstration d'IBM 1401 de moi, ils peuvent même lancer mon programme Pi .

Je tiens à remercier le Computer History Museum et les membres de l'équipe de récupération informatique 1401: Robert Garner, Ed Thelen, Van Snyder et surtout Stan Paddock. Le site Web de l' équipe ibm-1401.info contient de nombreuses informations intéressantes sur l'ordinateur 1401 et comment le restaurer.

Explication

Il est à noter que je n'ai pas écrasé le vrai bloc sur IBM 1401 - le Museum of Computer History ne l'aimerait pas. Comme je l’ai dit, avec un IBM 1401 en état de marche, vous ne pourrez pas gagner de l’argent grâce à l’exploitation minière. Cependant, j'ai réussi à implémenter et exécuter l'algorithme SHA-256 sur une machine IBM 1401, prouvant ainsi que l'exploitation minière est théoriquement possible. Et je vais révéler le secret de la recherche d'un hachage valide - je viens d'utiliser le bloc déjà miné .

Nous espérons que vous avez apprécié notre traduction

Exploiter des bitcoins sur IBM 1401, un vétéran de 55 ans