Gehen, midstate SHA-256-hash

Mit 128 bytes von Daten, zum Beispiel:

00000001c570c4764aadb3f09895619f549000b8b51a789e7f58ea750000709700000000103ca064f8c76c390683f8203043e91466a7fcc40e6ebc428fbcc2d89b574a864db8345b1b00b5ac00000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000

Zu wollen, führen SHA-256-hash auf, es wäre zu trennen, die in zwei 64-Byte Daten und hash Sie einzeln vor der Vermischung die Ergebnisse zusammen. Wenn man zu oft zu ändern, einige bits in der zweiten Hälfte der Daten, könnte man vereinfacht die Berechnungen und hash der ersten Hälfte der Daten nur einmal. Wie würde man das in Google Gehen? Ich habe versucht, den Aufruf

func SingleSHA(b []byte)([]byte){
    var h hash.Hash = sha256.New()
    h.Write(b)
    return h.Sum()
}

Aber statt der richtigen Antwort

e772fc6964e7b06d8f855a6166353e48b2562de4ad037abc889294cea8ed1070

Bekam ich

12E84A43CBC7689AE9916A30E1AA0F3CA12146CBF886B60103AEC21A5CFAA268

Bei der Erörterung der Frage, auf Bitcoin forum, jemand erwähnte, dass es sein könnte einige Probleme bekommen, die midstate hash.

Wie berechne ich eine midstate SHA-256-hash in Google Gehen?

  • Im Gehen 1.0.3, Summe dauert ein byte-slice, also müssen Sie schreiben h.Sum([]byte{}) zurück
  • h.Sum(nil) gilt auch, @emicklei 🙂
InformationsquelleAutor ThePiachu | 2012-02-12
  1. 5

    Bitcoin-bezogene byte-Operationen sind ein bisschen schwierig, da Sie oft wechseln endianness nach Laune. Zuerst nehmen wir den ersten []byte array mit

    00000001c570c4764aadb3f09895619f549000b8b51a789e7f58ea750000709700000000103ca064f8c76c390683f8203043e91466a7fcc40e6ebc428fbcc2d89b574a864db8345b1b00b5ac00000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000

    Dann trennen wir die erste Hälfte des Arrays, der Beschaffung:

    00000001c570c4764aadb3f09895619f549000b8b51a789e7f58ea750000709700000000103ca06 4f8c76c390683f8203043e91466a7fcc40e6ebc428fbcc2d8

    Danach müssen wir tauschen einige bytes um. Kehren wir die Reihenfolge der bytes in jedem slice of 4 bytes, wie folgt abrufen:

    0100000076C470C5F0B3AD4A9F619598B80090549E781AB575EA587F977000000000000064A03C10396CC7F820F8830614E94330C4FCA76642BC6E0ED8C2BC8F

    ... Und dass ist die Reihe, die wir verwenden werden für die Berechnung der midstate. Nun müssen wir ändern, um die Datei hash.go hinzufügen type Hash interface:

    Midstate() []byte

    Und ändern Sie die Datei sha256.go hinzufügen diese Funktion:

    func (d *digest) Midstate() []byte {
    var answer []byte
    for i:=0;i<len(d.h);i++{
        answer=append(answer[:], Uint322Hex(d.h[i])...)
    }
    return answer
}

    Wo Uint322Hex wandelt ein uint32 variable in eine []byte variable. Mit allem, was wir nennen können:

    var h BitSHA.Hash = BitSHA.New()
h.Write(Str2Hex("0100000076C470C5F0B3AD4A9F619598B80090549E781AB575EA587F977000000000000064A03C10396CC7F820F8830614E94330C4FCA76642BC6E0ED8C2BC8F"))
log.Printf("%X", h.Midstate())

    Wo Str2Hex stellt eine string in []byte. Das Ergebnis ist:

    69FC72E76DB0E764615A858F483E3566E42D56B2BC7A03ADCE9492887010EDA8

    Erinnern, die richtige Antwort:

    e772fc6964e7b06d8f855a6166353e48b2562de4ad037abc889294cea8ed1070

    Wir können Sie vergleichen:

    69FC72E7 6DB0E764 615A858F 483E3566 E42D56B2 BC7A03AD CE949288 7010EDA8
e772fc69 64e7b06d 8f855a61 66353e48 b2562de4 ad037abc 889294ce a8ed1070

    So können wir sehen, dass wir uns nur zum vertauschen von bytes um ein bit in jeder Scheibe 4 bytes, und wir haben die richtigen "midstate" von Bitcoin-pools und Minern (bis es nicht mehr benötigt wegen wird nicht mehr unterstützt).

    • Würden Sie mir ausführlich, wie Sie ging von 0100000076C470C5F0B3AD4A9F619598B80090549E781AB575EA587F977000000000000064A03C10396CC7F820F8830614E94330C4FCA76642BC6E0ED8C2BC8F zu 69FC72E76DB0E764615A858F483E3566E42D56B2BC7A03ADCE9492887010EDA8 für jemanden, der nicht weiß, Gehen? Es sieht aus wie Sie sind, Durchlaufen die hex (konvertiert von string-hex raw hex), etwas zu tun mit unsigned ints, und konvertieren Sie zurück zu hex. Ich bin mir nicht sicher, wo die int-Werte sind, die aus oder was machst du mit Ihnen... jede Hilfe wäre sehr geschätzt werden!
    • Tut mir Leid, ich bin besorgt, einige der Magie getan werden könnte intern durch den SHA-Algorithmus. Darüber hinaus war es eine lange Zeit, seit ich spielte mit dieser. Mal sehen, ich habe die hex array in die Funktion Schreiben, um es zu laden in SHA. Der Algorithmus verarbeitet die zahlen in der Write-Funktion, und speichert Sie in einem array von unsigned int-Werten. Ich Ihre Werte erhalten und verwandeln diese in ein array von Verhexungen. Ich denke, das ist es.
    • Vielen Dank für die Hilfe. Ich werde weiter tuckern.
    InformationsquelleAutor ThePiachu
  2. 3

    Den Go-code, den Sie haben, ist der richtige Weg, um zu berechnen, sha256 von einem Strom von bytes.

    Wahrscheinlich die Antwort ist, dass das, was Sie wollen zu tun ist, nicht sha256. Speziell:

    müsste man es trennen in zwei 64-bit-Daten und hash Sie einzeln vor der Vermischung die Ergebnisse zusammen. Wenn man zu oft zu ändern, einige bits in der zweiten Hälfte der Daten, könnte man vereinfacht die Berechnungen und hash der ersten Hälfte der Daten nur einmal.

    nicht einen gültigen Weg zur Berechnung von sha256 (Lesen http://doc.golang.org/src/pkg/crypto/sha256/sha256.go z.B. sehen, dass sha256 tut seine Arbeit auf Blöcke von Daten, die müssen aufgefüllt werden, etc.).

    Den Algorithmus, den Sie beschrieben, berechnet etwas, aber nicht sha256.

    Da Sie wissen, den erwarteten Wert, den Sie vermutlich haben einige Referenz-Implementierung des Algorithmus in einer anderen Sprache also nur ein line-by-line-Anschluss zu Gehen.

    Schließlich ist es eine zweifelhafte Optimierung in jedem Fall. 128 bit, 16 bytes. Hashing Kosten ist in der Regel proportional zu der Größe der Daten. Bei 16 bytes, die Kosten so gering, dass die zusätzliche Arbeit zu versuchen, clever zu sein durch die Aufteilung der Daten in 8 byte-Teile werden wahrscheinlich mehr Kosten als das, was Sie gespeichert haben.

    • Sorry, ich meinte bytes, nicht bits. Die Umsetzung wäre die Nutzung dieser Daten ist nur gedacht für das hashing der Daten zusammen, die Veränderung der zweiten Hälfte der saite, so dass die Berechnung der midstate spart einen beträchtlichen Teil des computing Aufgabe.
    • Ich würde die benchmark die "beträchtlichen Teil". Mir 64 vs 128 bytes ist unbedeutend, vor allem, wenn man bedenkt, wie sha256 funktioniert. Sha256 operiert auf Blöcken von mindestens 56 bytes. Statt der sequenziellen sha256-128 bytes, die Sie wollen, es zu tun auf 64 bytes (gepolstert 2*56 D. H. 112), für sha256 von der Hälfte der Daten plus wieder auf 32+32 (32 ist die Größe des sha256-Prüfsumme) plus den Aufwand die Einrichtung zusätzlicher sha256-Prozess. In der Tat, tut es auf 128 bytes schneller sein soll (und die Ergebnisse sind nicht gleichwertig).
    InformationsquelleAutor Krzysztof Kowalczyk
  3. 2

    In sha256.gehen, am Anfang der Funktion Sum() die Umsetzung ist eine Kopie des SHA256-Zustand. Der zugrunde liegende Datentyp der SHA256 (struct digest) ist privat, um den sha256-Paket.

    Ich würde vorschlagen, um Ihre eigene private Kopie der sha256.go Datei (es ist eine kleine Datei). Dann fügen Sie eine Copy() - Funktion speichern Sie den aktuellen Stand der digest:

    func (d *digest) Copy() hash.Hash {
    d_copy := *d
    return &d_copy
}

    Dann rufen Sie einfach die Copy() - Funktion zum speichern einer midstate SHA256-hash.

    • Haben Sie kompilieren und testen Sie Ihren code?
    • Was meinst du?
    • Eigentlich benötigt man auch ändern hash.go-Datei zum ändern des hash.Hash-Schnittstelle, um eine zu nennen, Copy(), aber auch nach, dass ich auf das Ergebnis [BE7E1F35 A19D5938 D8E6A17B 6BDF4738 603BB417 9AE97BCE FAED662 C11CB2F7].
    • Okay, mal sehen... Stellt sich heraus, Bitcoins sind ein bisschen schwierig, mit Ihren endianness und viele seltsame byte-swapping Los ist, bevor das Eingangssignal zugeführt wird, in die SHA-Funktion. Am Ende wird diese Lösung mit einigen änderungen funktionieren würde.
    InformationsquelleAutor
  4. 0

    Lief ich zwei benchmarks Gehen auf Ihre 128 bytes von Daten, mit einem Intel i5 2.70 GHz CPU. Ersten, 1.000 mal, ich schrieb alle 128 bytes, um den SHA256-hash und Lesen Sie die Summe, die insgesamt über 9,285,000 Nanosekunden. Zweitens, ich schrieb die ersten 64 bytes auf den SHA256-hash einmal und dann 1.000 mal schrieb ich die zweite 64 bytes, eine Kopie des SHA256-hash und Lesen Sie die Summe, die insgesamt über 6,492,371 Nanosekunden. Der zweite benchmark, die davon ausgegangen, die ersten 64 Byte sind invariant, lief in 30% weniger Zeit als die ersten benchmark.

    Hilfe der ersten Methode, man könnte berechnen, über 9,305,331,179 SHA256 128-byte-Summen pro Tag, vor dem Kauf eine schnellere CPU. Mithilfe der zweiten Methode konnten Sie berechnen 13,307,927,103 SHA256 128-byte-Summen pro Tag, vorausgesetzt, dass die ersten 64 bytes sind invariant 1.000-mal in einer Reihe, vor dem Kauf eine schnellere CPU. Wie viele SHA256 128-byte-Summen pro Tag, müssen Sie berechnen? Für wie viele SHA256 128-byte-Summen pro Tag werden die ersten 64 Byte sind invariant?

    Welche Maßstäbe haben Sie laufen, und was waren die Ergebnisse?

    InformationsquelleAutor peterSO
Schreibe einen Kommentar