Go, хэш SHA-256 среднего штата

Операции с байтами, связанные с биткойнами, немного сложны, поскольку они имеют тенденцию переключать порядок байтов по прихоти. Во-первых, мы берем исходный массив []byte, представляющий

00000001c570c4764aadb3f09895619f549000b8b51a789e7f58ea750000709700000000103ca064f8c76c390683f8203043e91466a7fcc40e6ebc428fbcc2d89b574a864db8345b1b00b5ac00000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000

Затем мы выделяем первую половину массива, получая:

00000001c570c4764aadb3f09895619f549000b8b51a789e7f58ea750000709700000000103ca06 4f8c76c390683f8203043e91466a7fcc40e6ebc428fbcc2d8

После этого нам нужно поменять местами несколько байтов. Мы меняем порядок байтов в каждом фрагменте из 4 байтов, таким образом получая:

0100000076C470C5F0B3AD4A9F619598B80090549E781AB575EA587F977000000000000064A03C10396CC7F820F8830614E94330C4FCA76642BC6E0ED8C2BC8F

И это массив, который мы будем использовать для вычисления среднего состояния. Теперь нам нужно изменить файл hash.go, добавив в type Hash interface:

Midstate() []byte

И измените файл sha256.go, добавив эту функцию:

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
}

Где Uint322Hex преобразует переменную uint32 в переменную []byte. Имея все это, мы можем вызвать:

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

Где Str2Hex превращает string в []byte. Результат:

69FC72E76DB0E764615A858F483E3566E42D56B2BC7A03ADCE9492887010EDA8

Вспомним правильный ответ:

e772fc6964e7b06d8f855a6166353e48b2562de4ad037abc889294cea8ed1070

Мы можем сравнить их:

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

Итак, мы видим, что нам просто нужно немного поменять местами байты в каждом фрагменте из 4 байтов, и у нас будет правильное «среднее состояние», используемое биткойн-пулами и майнерами (до тех пор, пока оно больше не будет нужно из-за того, что оно устарело).

Код Go, который у вас есть, — это правильный способ вычислить sha256 потока байтов.

Скорее всего, ответ заключается в том, что вы хотите сделать не sha256. Конкретно:

нужно было бы разделить его на два 64-битных данных и хешировать их по отдельности, прежде чем хешировать результаты вместе. Если бы нужно было часто менять некоторые биты во второй половине данных, можно было бы упростить вычисления и хэшировать первую половину данных только один раз.

не является допустимым способом вычисления sha256 (прочитайте http://doc.golang.org/src/pkg/crypto/sha256/sha256.go, чтобы, например, увидеть, что sha256 выполняет свою работу с блоками данных, которые должны быть дополнены и т. д.).

Описанный вами алгоритм что-то вычисляет, но не ша256.

Поскольку вы знаете ожидаемое значение, у вас, вероятно, есть эталонная реализация вашего алгоритма на другом языке, поэтому просто сделайте построчный порт на Go.

Наконец, сомнительная оптимизация в любом случае. 128 бит это 16 байт. Стоимость хеширования обычно пропорциональна размеру данных. При 16 байтах стоимость настолько мала, что дополнительная работа по умному разбиению данных на 8-байтовые части, вероятно, будет стоить больше, чем то, что вы сэкономили.

В sha256.go в начале функции Sum() реализация делает копия состояния SHA256. Базовый тип данных SHA256 (структура digest) является частным для пакета sha256.

Я бы предложил сделать вашу собственную копию файла sha256.go (это небольшой файл). Затем добавьте функцию Copy() для сохранения текущего состояния дайджеста:

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

Затем просто вызовите функцию Copy(), чтобы сохранить хэш среднего состояния SHA256.

Я провел два теста Go на ваших 128 байтах данных, используя процессор Intel i5 2,70 ГГц. Сначала я 1000 раз записал все 128 байт в хеш SHA256 и прочитал сумму, что в общей сложности заняло около 9 285 000 наносекунд. Во-вторых, я записал первые 64 байта в хеш SHA256 один раз, а затем 1000 раз записал вторые 64 байта в копию хэша SHA256 и прочитал сумму, что заняло в общей сложности около 6 492 371 наносекунд. Второй тест, предполагающий, что первые 64 байта неизменны, выполнялся на 30% быстрее, чем первый тест.

Используя первый метод, вы можете вычислить около 9 305 331 179 128-байтных сумм SHA256 в день, прежде чем покупать более быстрый процессор. Используя второй метод, вы можете вычислить 13 307 927 103 128-байтовых сумм SHA256 в день, предполагая, что первые 64 байта неизменны 1000 раз подряд, прежде чем покупать более быстрый процессор. Сколько 128-байтных сумм SHA256 в день вам нужно рассчитать? Для скольких 128-байтовых сумм SHA256 в день первые 64 байта являются инвариантными?

Какие бенчмарки вы проводили и каковы были результаты?