XDAG_Miner客户端到底做了什么

    开篇之前先聊聊背景：本人本身是想打造一个Python版本节点的，但是坑在了两个函数

• dfslib_crypt_set_sector0

• dfslib_encrypt_sector

这两个函数在节点和挖矿程序中都出现了，主要是对用户密码进行加密解密的函数，我尝试用Python翻译了一遍，效率极低，甚至都影响调试就放弃了。

    再对Python开发者说几句，整个XDAG代码并不多，但是其中运用了大量宏，字节截取，二进制处理，内存偏移等。导致对于Python这个语言来说，增加了大量转换工作，许多源码中一行的简单调用，在Python都要经过多行函数级处理才得已实现。所以Python初中级的朋友慎入～整个挖矿流程我用Python版本跑了一遍，效率比原版差了百倍，所以Python版本仅供参考研究使用，暂时无法投放在生产环境，本人在下个版本可能会参与到Go语言版本的重构中。

    言归正传，咱们走一遍整个GpuMiner都做了什么，其中涉及几个函数如下：

1， 生成_crypt变量，该变量是

MINERS_PWD经过开篇提到的两个函数加密之后得到的

2， 链接矿池，获取任务，看上去是获得了两个xdag_field结构体的任务，但其实后面是要结合起来加工的

3， 两个结构体任务分别经过dfslib_uncrypt_array函数，sectorNo参数分别是0和1

4， 通过AddressToHash函数把地址转换成Hash

5， task_ctx_data其实就是第二个获得的任务通过dfslib_uncrypt_array加密转换，再加上地址转换的Hash

6， task_ctx_state就是第一个任务通过dfslib_uncrypt_array加密之后的值

7， 变量main_time为当前时间经过GetMainTime函数的转换

8， nonce为一个2**64次方的随机数

9， minhash_data由一个数组[18446744073709551615,18446744073709551615,18446744073709551615,9895604649983]序列化得到

10， 从而可以输出所有变量如图：

11， 拿到了所有所需数据，下一步就要计算哈希了SearchMinNonce，其实这里有个小问题，SearchMinNonce得到最终是share时会多计算0-254次哈希，我个人判断，由于得到share需要经过大量哈希运算，作者为了方便编写就每256次为一组计算最小哈希，在和minhash做对比。

12， 拿到最小哈希和nonce并没有完，还需要通过dfslib_encrypt_array函数转换后，把fieldsCopy传回给矿池，整个过程结束。

本文提及的所有函数随后提供Python版本的Demo(由于时间问题，有点乱，不是很完整，多见谅)，欢迎大家多多交流～

import struct

import copy

import ctypes

import time

import random

import hashlib

import numpy as np

from regs import regs

class xdag_field:

    pass

class _crypt:

    pass

_c = _crypt()

_c.regs = regs

_c.pwd = [781665893, 3404732475, 2212684154, 3744338274]

_readDataSize = b'\x9c\x0f_%\x19\x8c!{\x02\xed\xa7\x87h\xc6\xc4\xca\x1c\xe7Ut\xa2\xd4\x13\x993|\x9d@\xa0\xc1\xa4\n\xf6d\xa51nn\xb9\x81\xa5\xec\x8b\xdc\xc0\x1dz\xa1\xcfi5\x89\xa0K ?\xf6\x93b\xa5\x87\x8czj'

a = struct.unpack('Q',_readDataSize[0:8])[0]

b = struct.unpack('Q',_readDataSize[8:16])[0]

c = struct.unpack('Q',_readDataSize[16:24])[0]

d = struct.unpack('Q',_readDataSize[24:32])[0]

xdag_field1 = xdag_field()

xdag_field1.transport_header = a

xdag_field1.type = b

xdag_field1.time = c

xdag_field1.hash = [a, b, c]

xdag_field1.amount = d

xdag_field1.end_time = d

xdag_field1.data = [a, b, c, d]

a = struct.unpack('Q',_readDataSize[32:40])[0]

b = struct.unpack('Q',_readDataSize[40:48])[0]

c = struct.unpack('Q',_readDataSize[48:56])[0]

d = struct.unpack('Q',_readDataSize[56:64])[0]

xdag_field2 = xdag_field()

xdag_field2.transport_header = a

xdag_field2.type = b

xdag_field2.time = c

xdag_field2.hash = [a, b, c]

xdag_field2.amount = d

xdag_field2.end_time = d

xdag_field2.data = [a, b, c, d]

def dfs_crypt0(dfsc, a,x,y,z,t):

    dfs64 = np.uint64(y[0])

    dfs16 = np.uint16(t[0])

    tmp = np.uint32(z[0] + dfsc.regs[x[0] >> 16])

    dfs32 = np.uint32(int(dfs64* tmp) >> 16)

    a[0] = dfs32 ^ dfsc.regs[dfs16]

    return a[0]

def dfs_crypt2(dfsc, a,b,c,d,x,y,z,t):

    dfs_crypt0(dfsc, a,x,y,z,t);dfs_crypt0(dfsc, b,y,z,t,x)

    dfs_crypt0(dfsc, c,z,t,x,y);dfs_crypt0(dfsc, d,t,x,y,z)

def dfs_crypt3(dfsc, a,b,c,d,x,y,z,t):

    dfs_crypt2(dfsc, a,b,c,d,x,y,z,t);dfs_crypt2(dfsc, x,y,z,t,a,b,c,d)

def dfs_crypt6(dfsc, a,b,c,d,x,y,z,t):

    dfs_crypt3(dfsc, a,b,c,d,x,y,z,t);dfs_crypt3(dfsc, a,b,c,d,x,y,z,t)

    dfs_crypt3(dfsc, a,b,c,d,x,y,z,t);dfs_crypt3(dfsc, a,b,c,d,x,y,z,t)

    dfs_crypt3(dfsc, a,b,c,d,x,y,z,t);dfs_crypt3(dfsc, a,b,c,d,x,y,z,t)

    dfs_crypt3(dfsc, a,b,c,d,x,y,z,t);dfs_crypt3(dfsc, a,b,c,d,x,y,z,t)

def dfs_uncrypt2(dfsc, a, b, c, d, x, y, z, t, data, num):

    dfs_crypt0(dfsc, c, z, t, x, y); data[num[0]]= np.uint32(data[num[0]]) + np.uint32(dfs_crypt0(dfsc, d, t, x, y, z))

    a[0] = dfs_crypt0(dfsc, a, x, y, z, t) ^ ~data[num[0]];num[0] +=1;dfs_crypt0(dfsc, b, y, z, t, x)

def dfs_uncrypt3(dfsc, a, b, c, d, x, y, z, t, data, num):

    dfs_uncrypt2(dfsc, a, b, c, d, x, y, z, t, data, num);dfs_uncrypt2(dfsc, x, y, z, t, a, b, c, d, data, num)

def dfs_prepare(dfsc, sectorNo, x, y, z, t):

    sectorNo = int(np.uint64(1229426917 << 32 | 3433359571) * np.uint64(sectorNo))

    x[0] = dfsc.pwd[0] ^ dfsc.regs[sectorNo%65479 + 31]

    y[0] = dfsc.pwd[1] ^ dfsc.regs[sectorNo%65497 + 11]

    z[0] = dfsc.pwd[2] ^ dfsc.regs[sectorNo%65519 + 5]

    t[0] = dfsc.pwd[3] ^ dfsc.regs[sectorNo%65521 + 3]

    a, b, c, d = [0], [0], [0], [0]

    dfs_crypt6(dfsc, a,b,c,d,x,y,z,t)

def dfs_unmix2(c, d, num):

    c[0] = np.uint32(c[0] * 43385317);

    num[0]-=1; 

    d[num[0]] ^=c[0]; c[0] ^= d[num[0]]

def dfs_unmixArray(d, num):

    c = [1615037507]

    for i in range(8):

        dfs_unmix2(c, d, num)

def dfslib_uncrypt_array(dfsc, data, sectorNo):

    a, b, c, d, x, y, z, t = [0], [0], [0], [0], [0], [0], [0], [0]

    dfs_prepare(dfsc, sectorNo, x, y, z, t)

    num = [0]

    data_list = []

    for _d in data:

        tmp = struct.pack('L', _d)

        data_list.append(struct.unpack('I', tmp[:4])[0])

        data_list.append(struct.unpack('I', tmp[4:])[0])

    for i in range(4):

        dfs_uncrypt3(dfsc, a, b, c, d, x, y, z, t, data_list, num)

    dfs_unmixArray(data_list, num)

    return data_list, [struct.unpack('L',struct.pack('I', data_list[0]) + struct.pack('I', data_list[1]))[0],

            struct.unpack('L',struct.pack('I', data_list[2]) + struct.pack('I', data_list[3]))[0],

            struct.unpack('L',struct.pack('I', data_list[4]) + struct.pack('I', data_list[5]))[0],

            struct.unpack('L',struct.pack('I', data_list[6]) + struct.pack('I', data_list[7]))[0]]

def GetMainTime():

    timer = time.time()

    tv_sec = int(timer)

    tv_usec = int((timer-tv_sec)*1000000)

    get_timestamp = tv_sec<<10 | int((tv_usec<<10)/1000000)

    MAIN_TIME = get_timestamp>>16

    MAIN_TIME = hex(MAIN_TIME)+'ffff'

    return MAIN_TIME

def AddressToHash(address):

    fld = b''

    _mime2bits = _mime2bits_init()

    e=n=0

    address_index = 0

    for i in range(32):

        while True:

            c = address[address_index]

            address_index+=1

            d = _mime2bits[c]

            if d&0xC0 == False:

                break

        e <<= 6

        e = np.uint16(e| d)

        n += 6

        if n>=8:

            n-=8

            fld += struct.pack('Q',e >> n)[:1]

    for i in range(8):

        fld+=b'\x00'

    return fld

def _mime2bits_init():

    bits2mime = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"    

    _mime2bits = [0xFF] * 256

    for i in range(64):

        _mime2bits[bits2mime[i]] = i

    return _mime2bits

def ReadBE32(x):

    return (((x & 0xff000000) >> 24) | ((x & 0x00ff0000) >> 8) | ((x & 0x0000ff00) << 8) | ((x & 0x000000ff) << 24))

def WriteBE64x32(x):

    return (((x & 0xff00000000000000) >> 24) | ((x & 0x00ff000000000000) >> 8) | ((x & 0x0000ff0000000000) << 8) | ((x & 0x000000ff00000000) << 24) | ((x & 0x00000000ff000000) >> 24) | ((x & 0x0000000000ff0000) >> 8) | ((x & 0x000000000000ff00) << 8) | ((x & 0x00000000000000ff) << 24))

def Ch(x, y, z):

    return z ^ (x & (y ^ z))

def Maj(x, y, z):

    return (x & y) | (z & (x | y))

def Sigma0(x):

    return (x >> 2 | x << 30) ^ (x >> 13 | x << 19) ^ (x >> 22 | x << 10)

def Sigma1(x):

    return (x >> 6 | x << 26) ^ (x >> 11 | x << 21) ^ (x >> 25 | x << 7)

def sigma0(x):

    return (x >> 7 | x << 25) ^ (x >> 18 | x << 14) ^ (x >> 3)

def sigma1(x):

    return (x >> 17 | x << 15) ^ (x >> 19 | x << 13) ^ (x >> 10)

def Round(a, b, c, d, e, f, g, h, k, w):

    t1 = h[0] + Sigma1(e[0]) + Ch(e[0], f[0], g[0]) + k[0] + w[0]

    t2 = Sigma0(a[0]) + Maj(a[0], b[0], c[0])

    d[0] = np.uint32(d[0] + t1)

    h[0] = np.uint32(t1 + t2)

def to_half(Buffer):

    return [struct.unpack('L',struct.pack('L',Buffer[i*2])[:4] + struct.pack('L',Buffer[i*2+1])[:4])[0] for i in range(len(Buffer)//2)]

def to_double(Buffer):

    new_Buffer = []

    for s in Buffer:

        tmp = struct.pack('L',s)

        new_Buffer.append(struct.unpack('I', tmp[:4])[0])

        new_Buffer.append(struct.unpack('I', tmp[4:])[0])

    return new_Buffer

def sha256_transform(s, chunk):

    s = to_half(s)

    s = to_double(s)

    a, b, c, d, e, f, g, h = [s[0]], [s[1]], [s[2]], [s[3]], [s[4]], [s[5]], [s[6]], [s[7]]

    w0 = [ReadBE32(chunk[0])]

    w1 = [ReadBE32(chunk[1])]

    w2 = [ReadBE32(chunk[2])]

    w3 = [ReadBE32(chunk[3])]

    w4 = [ReadBE32(chunk[4])]

    w5 = [ReadBE32(chunk[5])]

    w6 = [ReadBE32(chunk[6])]

    w7 = [ReadBE32(chunk[7])]

    w8 = [ReadBE32(chunk[8])]

    w9 = [ReadBE32(chunk[9])]

    w10 = [ReadBE32(chunk[10])]

    w11 = [ReadBE32(chunk[11])]

    w12 = [ReadBE32(chunk[12])]

    w13 = [ReadBE32(chunk[13])]

    w14 = [ReadBE32(chunk[14])]

    w15 = [ReadBE32(chunk[15])]

    Round(a, b, c, d, e, f, g, h, [0x428a2f98], w0)

    Round(h, a, b, c, d, e, f, g, [0x71374491], w1)

    Round(g, h, a, b, c, d, e, f, [0xb5c0fbcf], w2)

    Round(f, g, h, a, b, c, d, e, [0xe9b5dba5], w3)

    Round(e, f, g, h, a, b, c, d, [0x3956c25b], w4)

    Round(d, e, f, g, h, a, b, c, [0x59f111f1], w5)

    Round(c, d, e, f, g, h, a, b, [0x923f82a4], w6)

    Round(b, c, d, e, f, g, h, a, [0xab1c5ed5], w7)

    Round(a, b, c, d, e, f, g, h, [0xd807aa98], w8)

    Round(h, a, b, c, d, e, f, g, [0x12835b01], w9)

    Round(g, h, a, b, c, d, e, f, [0x243185be], w10)

    Round(f, g, h, a, b, c, d, e, [0x550c7dc3], w11)

    Round(e, f, g, h, a, b, c, d, [0x72be5d74], w12)

    Round(d, e, f, g, h, a, b, c, [0x80deb1fe], w13)

    Round(c, d, e, f, g, h, a, b, [0x9bdc06a7], w14)

    Round(b, c, d, e, f, g, h, a, [0xc19bf174], w15)

    K = [0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,

         0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,

         0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2]

    K_index = 0

    for i in range(3):

        w0[0] = np.uint32(w0[0] + sigma1(w14[0]) + w9[0] + sigma0(w1[0]))

        w1[0] = np.uint32(w1[0] + sigma1(w15[0]) + w10[0] + sigma0(w2[0]))

        w2[0] = np.uint32(w2[0] + sigma1(w0[0]) + w11[0] + sigma0(w3[0]))

        w3[0] = np.uint32(w3[0] + sigma1(w1[0]) + w12[0] + sigma0(w4[0]))

        w4[0] = np.uint32(w4[0] + sigma1(w2[0]) + w13[0] + sigma0(w5[0]))

        w5[0] = np.uint32(w5[0] + sigma1(w3[0]) + w14[0] + sigma0(w6[0]))

        w6[0] = np.uint32(w6[0] + sigma1(w4[0]) + w15[0] + sigma0(w7[0]))

        w7[0] = np.uint32(w7[0] + sigma1(w5[0]) + w0[0] + sigma0(w8[0]))

        w8[0] = np.uint32(w8[0] + sigma1(w6[0]) + w1[0] + sigma0(w9[0]))

        w9[0] = np.uint32(w9[0] + sigma1(w7[0]) + w2[0] + sigma0(w10[0]))

        w10[0] = np.uint32(w10[0] + sigma1(w8[0]) + w3[0] + sigma0(w11[0]))

        w11[0] = np.uint32(w11[0] + sigma1(w9[0]) + w4[0] + sigma0(w12[0]))

        w12[0] = np.uint32(w12[0] + sigma1(w10[0]) + w5[0] + sigma0(w13[0]))

        w13[0] = np.uint32(w13[0] + sigma1(w11[0]) + w6[0] + sigma0(w14[0]))

        w14[0] = np.uint32(w14[0] + sigma1(w12[0]) + w7[0] + sigma0(w15[0]))

        w15[0] = np.uint32(w15[0] + sigma1(w13[0]) + w8[0] + sigma0(w0[0]))

        Round(a, b, c, d, e, f, g, h, [K[K_index]], w0);K_index+=1

        Round(h, a, b, c, d, e, f, g, [K[K_index]], w1);K_index+=1

        Round(g, h, a, b, c, d, e, f, [K[K_index]], w2);K_index+=1

        Round(f, g, h, a, b, c, d, e, [K[K_index]], w3);K_index+=1

        Round(e, f, g, h, a, b, c, d, [K[K_index]], w4);K_index+=1

        Round(d, e, f, g, h, a, b, c, [K[K_index]], w5);K_index+=1

        Round(c, d, e, f, g, h, a, b, [K[K_index]], w6);K_index+=1

        Round(b, c, d, e, f, g, h, a, [K[K_index]], w7);K_index+=1

        Round(a, b, c, d, e, f, g, h, [K[K_index]], w8);K_index+=1

        Round(h, a, b, c, d, e, f, g, [K[K_index]], w9);K_index+=1

        Round(g, h, a, b, c, d, e, f, [K[K_index]], w10);K_index+=1

        Round(f, g, h, a, b, c, d, e, [K[K_index]], w11);K_index+=1

        Round(e, f, g, h, a, b, c, d, [K[K_index]], w12);K_index+=1

        Round(d, e, f, g, h, a, b, c, [K[K_index]], w13);K_index+=1

        Round(c, d, e, f, g, h, a, b, [K[K_index]], w14);K_index+=1

        Round(b, c, d, e, f, g, h, a, [K[K_index]], w15);K_index+=1

    s[0] += a[0];

    s[1] += b[0];

    s[2] += c[0];

    s[3] += d[0];

    s[4] += e[0];

    s[5] += f[0];

    s[6] += g[0];

    s[7] += h[0];

    return s

def shasha(state, data, nonce):

    stateBuffer = [struct.unpack('I',state[i*4:i*4+4])[0] for i in range(8)]

    data = data[:56] + struct.pack('L', nonce)

    dataBuffer = [struct.unpack('I',data[i*4:i*4+4])[0] for i in range(16)]

    stateBuffer = sha256_transform(stateBuffer, dataBuffer)

    dataBuffer[0] = 0x80

    dataBuffer[1] = 0

    dataBuffer[2] = 0

    dataBuffer[3] = 0

    dataBuffer[4] = 0

    dataBuffer[5] = 0

    dataBuffer[6] = 0

    dataBuffer[7] = 0

    dataBuffer[8] = 0

    dataBuffer[9] = 0

    dataBuffer[10] = 0

    dataBuffer[11] = 0

    dataBuffer[12] = 0

    dataBuffer[13] = 0

    dataBuffer[14] = 0

    dataBuffer[15] = 1048576

    stateBuffer = sha256_transform(stateBuffer, dataBuffer)

    stateBuffer = to_half(stateBuffer)

    dataBuffer = to_half(dataBuffer)

    for i in range(4):

        dataBuffer[i] = WriteBE64x32(stateBuffer[i])

    stateBuffer[0] = 0xbb67ae856a09e667

    stateBuffer[1] = 0xa54ff53a3c6ef372

    stateBuffer[2] = 0x9b05688c510e527f

    stateBuffer[3] = 0x5be0cd191f83d9ab

    dataBuffer[4] = 0x80

    dataBuffer[7] = 0x0001000000000000

    new_stateBuffer = to_double(stateBuffer)

    new_dataBuffer = to_double(dataBuffer)     

    stateBuffer = sha256_transform(new_stateBuffer, new_dataBuffer)

    stateBuffer = to_half(stateBuffer)

    hash = [0,0,0,0]

    for i in range(4):

        hash[i] = WriteBE64x32(stateBuffer[i])    

    return hash

def CompareHashes(l, r):

    for i in range(3,-1,-1):

        if l[i] < r[i]:

            return True

        elif l[i] > r[i]:

            return False

    return False

def SearchMinNonce(task_ctx_state, task_ctx_data, nonce):

    for i in range(256):

        currentHash = shasha(task_ctx_state, task_ctx_data, nonce[0])

        if i==0 or CompareHashes(currentHash,hash):

            hash = copy.deepcopy(currentHash)

            minNonce = nonce[0]

        nonce[0] = nonce[0] + 1

    return minNonce, hash

def HasNewShare(nonce):

    while True:

        last_amount, hash = SearchMinNonce(task_ctx_state, task_ctx_data, nonce)

        #last_amount, hash = SearchMinNonce(task_ctx_state, task_ctx_data, lastfield_amount)

        if CompareHashes(hash,minhash_data):

            print ('isShareFound')

            return last_amount, hash

        print (nonce)

state1, xdag_field_1 = dfslib_uncrypt_array(_c, xdag_field1.data,0)

state2, xdag_field_2 = dfslib_uncrypt_array(_c, xdag_field2.data,1)

state2_list = b''

for s in state2:

    tmp = struct.pack('I', s)

    state2_list+= tmp

addressHash = AddressToHash(b'gKNRtSL1pUaTpzMuPMznKw49ILtP6qX3')

task_ctx_data = state2_list + addressHash[:24]

task_ctx_state = b''

for s in state1:

    tmp = struct.pack('I', s)

    task_ctx_state+= tmp

main_time = GetMainTime()

print ('New task:\t',main_time[2:])

print ('State:')

print (task_ctx_state.hex())

print ('Data:')

print (task_ctx_data.hex())

lastfield_amount = random.randint(0, 2**64)

print ('Start nonce:\t', lastfield_amount)

print ('Start minhash:')

minhash_data = [18446744073709551615,18446744073709551615,18446744073709551615,9895604649983]

str_minhash_data = struct.pack('>Q',minhash_data[3])+struct.pack('>Q',minhash_data[2])+struct.pack('>Q',minhash_data[1])+struct.pack('>Q',minhash_data[0])

print (str_minhash_data.hex())

a = struct.unpack('L',addressHash[:8])[0]

b = struct.unpack('L',addressHash[8:16])[0]

c = struct.unpack('L',addressHash[16:24])[0]

d = lastfield_amount

lastfield = xdag_field()

lastfield.transport_header = a

lastfield.type = b

lastfield.time = c

lastfield.hash = [a, b, c]

lastfield.amount = d

lastfield.end_time = d

lastfield.data = [a, b, c, d]

last_amount, hash = HasNewShare([3980675776616400062])

lastfield.amount = last_amount

lastfield.end_time = last_amount

#lastfield.data[3] = last_amount

lastfield.data[3] = 11277376069999640039

def dfs_encrypt2(dfsc, a, b, c, d, x, y, z, t, data, num):

    a[0] = np.uint32(dfs_crypt0(dfsc, a, x, y, z, t)) ^ np.uint32(~data[num[0]]); dfs_crypt0(dfsc, b, y, z, t, x)

    dfs_crypt0(dfsc, c, z, t, x, y);

    data[num[0]] = np.uint32(data[num[0]]) - np.uint32(dfs_crypt0(dfsc, d, t, x, y, z));

    num[0] +=1

def dfs_encrypt3(dfsc, a, b, c, d, x, y, z, t, data, num):

    dfs_encrypt2(dfsc, a, b, c, d, x, y, z, t, data, num);dfs_encrypt2(dfsc, x, y, z, t, a, b, c, d, data, num)

def dfs_enmix2(c,d, num):

    num[0] -=1

    d[num[0]] = d[num[0]] ^np.uint32(c[0] * 43385317)

    c[0] = d[num[0]]

def dfs_enmixArray(d, num):

    c = [1615037507]

    for i in range(8):

        dfs_enmix2(c, d, num)

def dfslib_encrypt_array(dfsc, data):

    a, b, c, d, x, y, z, t = [0], [0], [0], [0], [0], [0], [0], [0]

    dfs_prepare(dfsc, 16, x, y, z, t)#sectorNo=16

    num = [8]

    data = to_double(data)

    dfs_enmixArray(data, num)

    num = [0]

    for i in range(4):

        dfs_encrypt3(dfsc, a, b, c, d, x, y, z, t, data, num)

    return to_half(data)

fieldsCopy = dfslib_encrypt_array(_c, lastfield.data)

Write = b''

for f in fieldsCopy:

    Write += struct.pack('L', f)

print (Write)

print (123)