WICHTIG Hash256 Blockchain Demo HILFE mit reward bei Wunsch

[Oria]

Guten Tag allerseits

ich habe eine Aufgabe erhalten für eine Sonderseminar zu Blockchain,

und zwar muss ich auf folgender Webseite: https://andersbrownworth.com/blockchain/blockchain

in Block # 1
unter Daten meinen Namen eingeben Vor und Nachname
während ind prev 64 x die 0 darin steht

das ist die Ausgangslage nun muss ich eine Nonce finden die mir einen Hash unten ausgibt die mit möglichst vielen 0 beginnt


wenn ich das auf der Webseite mache und auf mine drücke erhalte ich einen hash die mit 4 x 0 beginnt

für jede 0 erhalte ich einen punkt 10/10 ist das maximum. wir dürfen alles verwenden auch KI und den Sourcecode der Webseite etc etc



Jetzt habe ich mit Python folgenden Code:

import hashlib

def generate_hash(prev, data, nonce):
text = prev + data + str(nonce)
return hashlib.sha256(text.encode('utf-8')).hexdigest()

def find_nonce_with_leading_zeros(prev, data, leading_zeros):
target = '0' * leading_zeros
nonce = 0
while True:
hash_result = generate_hash(prev, data, nonce)
if hash_result.startswith(target):
return nonce, hash_result
nonce += 1

prev = '0' * 64
data = 'Oriya Eckhardt'
leading_zeros = 8

nonce, hash_result = find_nonce_with_leading_zeros(prev, data, leading_zeros)
print(f'Nonce: {nonce}')
print(f'Hash: {hash_result}')


mir wurden mehrere Nonce berechnet für 8 leading zeros während im Datafeld der Name Oriya Eckhardt geschrieben steht$

gab mir der code folgenden output: Nonce for 8 leading zeros: 2747188028 dazugehörender hash: 0000000062046..... Wenn ich nun auf der Blockchain Demo seite bei block Nummer 1 in Daten Oriya Eckhardt eingebe und die nonce: 2747188028 eingebe erhalte ich folgenden hash : f29d7cfe997ba1934934fde9dde0b0e13324c7409a5577f1bd5cba4763b073ad


also keine einzige 0

dann habe ich es mit geckodriver probiert lief auch nicht ist mir auch etwas kompliziert.

und dann habe ich versucht halt den sourcecode der blockchain der Webseite in Java zu finden


war folgender : var difficulty = 4; // number of zeros required at front of hash
var maximumNonce = 500000; // limit the nonce to this so we don't mine too long

// NOTE: Because there are 16 possible characters in a hex value, each time you increment
// the difficulty by one you make the puzzle 16 times harder. In my testing, a difficulty
// of 6 requires a maximumNonce well over 500,000,000.

/////////////////////////
// global variable setup
/////////////////////////
var pattern = '';
for (var x=0; x<difficulty; x++) {
pattern += '0';
}

/////////////////////////
// functions
/////////////////////////
function sha256(block, chain) {
// calculate a SHA256 hash of the contents of the block
return CryptoJS.SHA256(getText(block, chain));
}

function updateState(block, chain) {
// set the well background red or green for this block
if ($('#block'+block+'chain'+chain+'hash').val().substr(0, difficulty) === pattern) {
$('#block'+block+'chain'+chain+'well').removeClass('well-error').addClass('well-success');
}
else {
$('#block'+block+'chain'+chain+'well').removeClass('well-success').addClass('well-error');
}
}

function updateHash(block, chain) {
// update the SHA256 hash value for this block
$('#block'+block+'chain'+chain+'hash').val(sha256(block, chain));
updateState(block, chain);
}

function updateChain(block, chain) {
// update all blocks walking the chain from this block to the end
for (var x = block; x <= 5; x++) {
if (x > 1) {
$('#block'+x+'chain'+chain+'previous').val($('#block'+(x-1).toString()+'chain'+chain+'hash').val());
}
updateHash(x, chain);
}
}

function mine(block, chain, isChain) {
for (var x = 0; x <= maximumNonce; x++) {
$('#block'+block+'chain'+chain+'nonce').val(x);
$('#block'+block+'chain'+chain+'hash').val(sha256(block, chain));
if ($('#block'+block+'chain'+chain+'hash').val().substr(0, difficulty) === pattern) {
if (isChain) {
updateChain(block, chain);
}
else {
updateState(block, chain);
}
break;
}
}
}



dazu liess ich fogenden python code genearieren: jedenfalls waren die gefunden noncewerte auch nicht jene die zu 3 leading zeros im hash führten jede zusätzlikche 0 gewährt einen Punkt maximal 10

4 kann ich von hand minen

aber den rest mnuss ich mit einem Programm suchen.


Bitte helft mir es ist eine sehr wichtige Note die ich für den Masterstudiengang benötige, ich bin schon eine Woche an dieser Aufgabe. Es benötigt jedes mal 16 x länger um eine zusätzliche 0 zu finden.

Ich habe auch mit multiprocessing gearbeitet aber das hilft nicht wenn ich die falschen nonce erhalte,


DANKE an jeden der mir hier Hilft ich würde sogar ein Geschenk schicken wenn mir jemand dabei hilft.

[Sirius3]

Erster Schritt wäre ja, herauszufinden, wie der Hash berechnet wird.
Wenn man das weiß, ist das anpassen des Python-Codes relativ einfach.
Noch einfacher wäre es, einfach den Javascript-Code statt vier acht Nullen rechnen zu lassen.

Aber bis zum Abgabetermin wird die Zeit wahrscheinlich nicht reichen.

[DeaD_EyE]

Code: Alles auswählen

"""
https://andersbrownworth.com/blockchain/blockchain
"""

"""
var difficulty = 4;        // number of zeros required at front of hash
var maximumNonce = 500000; // limit the nonce to this so we don't mine too long

// NOTE: Because there are 16 possible characters in a hex value, each time you increment
// the difficulty by one you make the puzzle 16 times harder. In my testing, a difficulty
// of 6 requires a maximumNonce well over 500,000,000.

/////////////////////////
// global variable setup
/////////////////////////
var pattern = '';
for (var x=0; x<difficulty; x++) {
  pattern += '0';
}

/////////////////////////
// functions
/////////////////////////
function sha256(block, chain) {
  // calculate a SHA256 hash of the contents of the block
  return CryptoJS.SHA256(getText(block, chain));
}

function updateState(block, chain) {
  // set the well background red or green for this block
  if ($('#block'+block+'chain'+chain+'hash').val().substr(0, difficulty) === pattern) {
    $('#block'+block+'chain'+chain+'well').removeClass('well-error').addClass('well-success');
  }
  else {
    $('#block'+block+'chain'+chain+'well').removeClass('well-success').addClass('well-error');
  }
}

function updateHash(block, chain) {
  // update the SHA256 hash value for this block
  $('#block'+block+'chain'+chain+'hash').val(sha256(block, chain));
  updateState(block, chain);
}

function updateChain(block, chain) {
  // update all blocks walking the chain from this block to the end
  for (var x = block; x <= 5; x++) {
    if (x > 1) {
      $('#block'+x+'chain'+chain+'previous').val($('#block'+(x-1).toString()+'chain'+chain+'hash').val());
    }
    updateHash(x, chain);
  }
}

function mine(block, chain, isChain) {
  for (var x = 0; x <= maximumNonce; x++) {
    $('#block'+block+'chain'+chain+'nonce').val(x);
    $('#block'+block+'chain'+chain+'hash').val(sha256(block, chain));
    if ($('#block'+block+'chain'+chain+'hash').val().substr(0, difficulty) === pattern) {
      if (isChain) {
        updateChain(block, chain);
      }
      else {
        updateState(block, chain);
      }
      break;
    }
  }
}
"""

# setup chain
"""
$(function() {
  setup(1, 1);
  setup(2, 1);
  setup(3, 1);
  setup(4, 1);
  setup(5, 1);
});

function getText(block, chain) {
  return $('#block'+block+'chain'+chain+'number').val() +
         $('#block'+block+'chain'+chain+'nonce').val() +
         $('#block'+block+'chain'+chain+'data').val() +
         $('#block'+block+'chain'+chain+'previous').val();
}

function setup(block, chain) {
  updateHash(block, chain);
  $('#block'+block+'chain'+chain+'number').bind('input propertychange', function() { updateChain(block, chain); });
  $('#block'+block+'chain'+chain+'nonce').bind('input propertychange', function() { updateChain(block, chain); });
  $('#block'+block+'chain'+chain+'data').bind('input propertychange', function() { updateChain(block, chain); });
  $('#block'+block+'chain'+chain+'mineButton').click(function(e) {
      e.preventDefault();
      var l = Ladda.create(this);
      l.start();
      setTimeout(function() {
          mine(block, chain, true);
          l.stop();
        }, 250); // give UI time to update
    });
}
"""
from dataclasses import dataclass, field
from hashlib import sha256


DIFFICULTY = 4
MAXIMUM_NONCE = 500000
PATTERN = "0" * DIFFICULTY


@dataclass
class Block:
    number: int
    nonce: int | None = field(default=-1)
    data: str = field(default="")
    chain: int = field(default=1)
    previous: str = field(default="0" * 64)

    @property
    def hash(self):
        return sha256(
            f"{self.number}{self.nonce}{self.data}{self.previous}".encode(),
        ).hexdigest()

    @property
    def is_valid(self):
        return self.hash[:DIFFICULTY] == PATTERN

    def find_nonce(self):
        for nonce in range(MAXIMUM_NONCE):
            self.nonce = nonce
            if self.is_valid:
                return True

        self.nonce = -1
        return False


@dataclass
class Chain:
    blocks: list[Block] = field(default_factory=list)

    def add_block(self, data: str):
        if size := len(self):
            block_number = size + 1
            hash_prev = self[block_number - 2].hash
        else:
            block_number = 1
            hash_prev = "0" * 64

        self.blocks.append(Block(number=block_number, data=data, previous=hash_prev))

    def __getitem__(self, block_number: int) -> Block:
        return self.blocks[block_number]

    def __len__(self):
        return len(self.blocks)

    def find_nonces(self):
        for index, block in enumerate(self):
            if index > 0:
                block.previous = self[index - 1].hash

            if not block.find_nonce():
                raise RuntimeError(
                    "Konnte nonce nicht berechnen, da das Limit erreicht worden ist."
                )


chain1 = Chain()
chain1.add_block("a")
chain1.add_block("b")
chain1.add_block("c")
chain1.find_nonces()

for block in chain1:
    print(f"#{block.number} | Nonce: {block.nonce} | Hash: {block.hash}")

print()

Keine Gewähr, dass die Berechnung richtig ist. Aber für die Daten: a, b und c bekomme ich die passenden Nonce (komisches Wort).

#1 | Nonce: 78061 | Hash: 00001f491ad661a6a34ef37e4a1560ccee7a071d4d672133e79bba3bc2a54270
#2 | Nonce: 17639 | Hash: 00007f94566ff02ad43aff8440b97cfd06a4e04ff69ed2c272d44b68f3999b4a
#3 | Nonce: 115246 | Hash: 0000ec223e0094d92324cf3542e1abbeb4f02e269253c5253a333b21453aa669

[grubenfox]

Aus der Doku vom Modul hashlib:

For example: use sha256() to create a SHA-256 hash object. You can now feed this object with bytes-like objects (normally bytes) using the update method.

In dem bisherigen Python-Code ist mir immer zuwenig 'Byte' und zuviel 'String' enthalten.

64 Null-Bytes sind was anderes als 64 Null-Zeichen

Code: Alles auswählen

In [8]:   b'0' * 64
Out[8]: b'0000000000000000000000000000000000000000000000000000000000000000'

In [9]:   '0' * 64
Out[9]: '0000000000000000000000000000000000000000000000000000000000000000'

In [10]: b'0' * 64 == '0' * 64
Out[10]: False

[Sirius3]

@grubenfox: der ganze Algorithmus basiert auf utf8-kodierten Strings.

@DeaD_EyE: der nonce ist int | None, der default aber die magische Zahl -1.
chain wird gar nicht benutzt.

Mit ein paar einfachen Funktionen ist das meiner Meinung nach übersichtlicher:

Code: Alles auswählen

from hashlib import sha256

DIFFICULTY = 4
MAXIMUM_NONCE = 500000
PATTERN = "0" * DIFFICULTY


def calculate_hash(number, nonce, data, previous):
    return sha256(
        f"{number}{nonce}{data}{previous}".encode(),
    ).hexdigest()


def find_nonce(number, data, previous):
    nonce = 0
    for nonce in range(MAXIMUM_NONCE):
        hash = calculate_hash(number, nonce, data, previous)
        if hash[:DIFFICULTY] == PATTERN:
            return nonce, hash
    raise RuntimeError(
        "Konnte nonce nicht berechnen, da das Limit erreicht worden ist."
    )


def calculate_chain(blocks):
    previous = "0" * 64
    for number, block in enumerate(blocks, 1):
        nonce, hash = find_nonce(number, block, previous)
        print(f"#{number} | Nonce: {nonce} | Hash: {hash}")
        previous = hash


def main():
    calculate_chain(["a", "b", "c"])


if __name__ == "__main__":
    main()

[DeaD_EyE]

@DeaD_EyE: der nonce ist int | None, der default aber die magische Zahl -1.
chain wird gar nicht benutzt.

Mit ein paar einfachen Funktionen ist das meiner Meinung nach übersichtlicher:

Ich habe vergessen None aus den TypeHints wieder zu entfernen. Zuerst war der default-Wert None. Das habe ich geändert, aber den TypeHint vergessen zu entfernen.
Den Code habe ich so geschrieben, weil er mir gefällt, nicht um es anderen leichter verständlich zu machen. Der Aufgabe bis du jetzt nachgekommen.