张墨轩的技术宅

不忘初心,方得始终

[置顶] 我的微信公众号

第五弹(磁盘保护+穿透更新)

技术虽然每天日新月异,但是对技术的热爱却从未改变,总结过去,展望未来。对于一些公共场所的带硬盘的Windows PC,比如酒店或者网吧,既需要保护硬盘系统不被破坏,又需要对上面的一些软件进行更新,比如游戏。本模块是我以前开发的三层游戏更新平台客户端的核心模块,能保护磁盘的同时又可以更新指定的游戏或者软件。

演示截图:

强大的异步架构量化平台(alphahunter)

alphahunter是一个基于Python原生异步库(asyncio)实现的异步事件驱动开源量化策略研究/策略回测/量化交易/高频做市平台,本系统实现数据采集,存储,推送,研究,仿真模拟,线上模拟,实盘等全流程量化研究交易支持,各步骤规则,配置,接口高度统一,异步框架提高系统综合性能。

中低频基础框架如下图所示:

第四弹(Windows安全防火墙)

技术虽然每天日新月异,但是对技术的热爱却从未改变,总结过去,展望未来。这次发的是2008年开发的一个Windows安全组件,主要包括两个部分,一是内核驱动防火墙,通过白名单机制,阻止未授权的驱动的加载,并且通过HOOK SSDT的方式保护自身进程的安全,二是ARP防火墙,它通过NDIS中间层驱动捕获以太数据报文,过滤掉其中的恶意ARP报文。自夸一下,当年项目代码很工整,并且自定义了C++ stub,用于实现ddk下编译C++代码 :)

截图如下:

第三弹(PXE全自动网刻工具)

这是以前开发的一个网维小工具, 工具虽小作用却很大,它结合PXE+Ghost能够批量对局域网内pc进行操作,比如安装操作系统。

当需要统一维护大批电脑时(如批量安装操作系统),尤其适用于比如学校机房和网吧等,PXE技术的网络克隆方案是首选。

PXE(Preboot Execution Environment)是RPL(Remote Program Load)的升级品,它是基于TCP/IP、DHCP、TFTP 等Internet 协议之上的扩展网络协议。它在工作站启动之前便预置好其工作环境。两者不同之处在于RPL 是静态路由,而PXE 是动态路由。RPL 是根据网卡的MAC 再加上其它信息组成帧向服务器发出请求,服务器里已经有了这个MAC 数据,若匹配成功则进行远程启动。PXE则是根据服务器端收到的工作站地址,由DHCP 服务给这个MAC 地址指定一个IP 地址,即PXE 为工作站动态分配地址。工作站得到IP 地址后,从服务器上下载启动映像文件,在工作站内存中虚拟一个软驱,并将启动映象文件还原为实模式连网文件、系统内核文件和环境设置文件。像无盘工作站的各种工作环境,包括服务器名、共享目录名及网卡实模式驱动程序都是在此环境文件中设置的。

浅谈去中心化交易所生态

DeFi, 去中心化金融, 包含很多内容, 其中非常重要的一个领域就是去中心化交易所了.

简单把交易生态分成三个角色: <交易所>, <做市商>, <交易者>

<交易所>为交易提供基础设施, <做市商>作为流动性提供者, 为交易所提供流动性, <交易者>包括套利交易者, 对冲交易者, 散户, 机构等等.  <交易所>和<做市商>是利益共同体, 一起分享交易手续费等收入, 同时<交易所>还可以发行治理代币, <做市商>通过流动性挖矿方式获取治理代币奖励, 而<交易者>需要支付交易手续费, 如果把交易看成一门生意的话, 其实就是<交易所>和<做市商>一起赚<交易者>的钱.

从交易机制来说传统的中心化交易所和初代的去中心化交易所一般采用的都是订单簿+撮合机制, 本质是人和人交易, 而目前新一代的去中心化交易所大都采用AMM(自动化做市商)机制, 典型代表有Uniswap, Balancer, Curve, Bancor等. 在AMM自动化做市商机制下我们其实是和由智能合约实现的流动性代币对池交易, 在传统的订单簿+撮合机制下要成为做市商还是有一定门槛的, 一般需要有程序员,量化工程师等开发自动化做市程序,如果想更进一步可能还需要构建更巧妙的数学模型,比如将深度强化学习应用于高频做市程序, 然后还需要一定量的资金, 因为交易所一般对做市挂单额度都有要求. 而在智能合约+AMM机制下,做市就变得非常容易, 仅仅只需要向流动性池子按一定比率充值相应的代币就可以完成做市操作.

那么如何参入到游戏中来, 我们还是从<交易所>,<做市商>,<交易者>三个方面来看, 开设交易所, 这个难度显然太大. 成为做市商, 这是一个选项, 前面说了, 对于传统的订单簿+撮合机制, 还需要构建自动化做市程序,  而对于智能合约+AMM机制只需要向流动性池子充值就行, 不过采用AMM机制的去中心化交易所非常多, 各池子收益各不相同, 是否可以针对最优的AMM池子进行投资组合优化呢, 当然是可以的, Yearn Finance就是代表, 本质上不管是流动性挖矿还是staking或者借贷亦或是DEX的AMM, 其都是将代币存入存储池, 然后赚取收益, 完全可以进行投资组合优化. 最后从<交易者>角度看, 可以进行套利交易, 比如搬砖, 比如统计套利, 比如构建数学模型对价格进行预测, 买涨买跌, CTA交易等, 这些其实就属于最经典的量化交易了. 另外还可以做聚合交易, 在中心化交易所领域, AiCoin就是典型代表, 那么在去中心化交易所里面1inch.exchange就是典型代表. 另外就是还有些工具类的可以参入, 因为类似Uniswap这样的去中心化交易所一般只有简单的交易功能, 并没有类似中心化交易所那样全面的比如K线, 成交列表等信息展示功能, 亦或是限价单等功能, 所以像dextools, Unitrade等工具类应用就帮其补全这一块的功能.


asyncio要点

asyncio是一个异步并发库, 注意是并发, 不是并行. 利用 async/await 组合

`可等待对象`有三种主要类型: coroutine,Task,Future, `可等待对象`实现了__await__方法 (Task派生至Future)

coroutine 协程,实现异步模型的基本单元

Future 主要用于coroutine之间`执行权`的切换, 内部本质用的是yield, await future -> __await__ -> yeild,
这个类很大程度上模仿concurrent.futures.Future

Task将(coroutine,Future)整合到一起, 成为一个task, 然后交给loop去执行. add_done_callback可以
为Task添加完成通知回调

loop是一个任务执行队列循环, 底层用类似select机制, linux上可以用epoll, windows上可以
用wsaeventselect或者`完成端口`来实现`单线程多任务`异步非阻塞IO操作

asyncio.run -> loop.run_until_complete -> loop.run_forever()

下面是并发示例代码:

#==========================================================================
#==========================================================================

async def test1():
    """
    asyncio.sleep内部创建了一个future对象和一个定时运行的回调函数,
    然后await等待这个future对象,这样会交出`执行权`,
    然后等到指定时间回调函数被调用,在回调函数里面
    调用future.set_result函数,这样asyncio.sleep将重新获取`执行权`,并返回.
    代码如下:
    async def sleep(delay, result=None, *, loop=None):
        if delay <= 0:
            await __sleep0()
            return result
        
        if loop is None:
            loop = events.get_event_loop()
        future = loop.create_future()  #创建一个future对象
        h = loop.call_later(delay,
                            futures._set_result_unless_cancelled, #这个回调函数里面会调用future.set_result
                            future, result)
        try:
            return await future #进入等待状态,直到回调函数futures._set_result_unless_cancelled被调用
        finally:
            h.cancel()
    """
    obj = asyncio.sleep(3) #生成`协程对象`,并不是真正执行`协程函数`
    await obj              #真正执行协程函数,并且等待完成
    print("test1 done")

async def test2():
    obj = asyncio.sleep(3)
    await obj
    print("test2 done")

async def main():
    """
    方式一:
    这里是串行执行, 3+3 一共要等待6秒才完成
    """
    obj1 = test1()   #生成`协程对象`,并不是真正执行`协程函数`
    obj2 = test2()   #生成`协程对象`,并不是真正执行`协程函数`
    #obj1.send(None) #协程对象可以这样运行
    await obj1 #真正执行协程函数,并且等待完成
    await obj2 #真正执行协程函数,并且等待完成
    
    """
    方式二:
    这里是并发执行, 一共只需要大约3秒就完成
    """
    obj1 = test1()  #生成`协程对象`,并不是真正执行`协程函数`
    obj2 = test2()  #生成`协程对象`,并不是真正执行`协程函数`
    task1 = asyncio.create_task(obj1)#创建任务对象,并且加入到执行列表里面,Task派生至Future,所以这里可以看成是future对象
    task2 = asyncio.create_task(obj2)#创建任务对象,并且加入到执行列表里面,Task派生至Future,所以这里可以看成是future对象
    """
    因为上面asyncio.create_task把两个协程都排入了执行队列,
    具有并发执行的性质,所以下面虽然从代码看上去是一个接一个在等待,
    但两个任务实际是并发完成的,所以一共只需要大约3秒就完成了
    """
    await task1#其实就是等待一个future对象,task内部执行完协程后,会在这个future对象上调用future.set_result,这样await就会返回,后面的代码继续运行
    await task2#其实就是等待一个future对象,task内部执行完协程后,会在这个future对象上调用future.set_result,这样await就会返回,后面的代码继续运行
    
    """
    方式三:
    这里也是并发执行,一共只需要大约3秒就完成,而且从代码上看更容易理解是并发执行,不会产生歧义.
    
    asyncio.wait内部主要流程是会利用add_done_callback为传入的每个任务添加同一个`任务完成回调通知`函数,
    然后await等待一个future对象,等任务完成后,`任务完成回调通知`函数被调用,这个函数里面有个计数器,
    当计数为0,代表所有任务都完成,然后就会调用future.set_result,这样前面说的await调用就会返回,然后asyncio.wait就会返回
   
    代码如下:
    async def _wait(fs, timeout, return_when, loop):
    
        assert fs, 'Set of Futures is empty.'
        waiter = loop.create_future() #创建一个future对象,后面会用到
        timeout_handle = None
        if timeout is not None:
            timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
        counter = len(fs)
        #下面就是`任务完成回调通知`函数
        def _on_completion(f):
            nonlocal counter #计数器
            counter -= 1 #每完成一个任务计数器减一
            if (counter <= 0 or #计数器为0意味着任务都执行完毕了
                return_when == FIRST_COMPLETED or
                return_when == FIRST_EXCEPTION and (not f.cancelled() and
                                                    f.exception() is not None)):
                if timeout_handle is not None:
                    timeout_handle.cancel()
                if not waiter.done():
                    waiter.set_result(None) #任务都执行完毕,调用set_result,这样后面await waiter代码就会返回,流程得以继续
    
        for f in fs:
            f.add_done_callback(_on_completion) #为每个任务添加`任务完成回调通知`函数
    
        try:
            await waiter #等待之前创建的future对象
        finally:
            if timeout_handle is not None:
                timeout_handle.cancel()
    
        done, pending = set(), set()
        for f in fs:
            f.remove_done_callback(_on_completion)
            if f.done():
                done.add(f)
            else:
                pending.add(f)
        return done, pending
    """
    obj1 = test1()  #生成`协程对象`,并不是真正执行`协程函数`
    obj2 = test2()  #生成`协程对象`,并不是真正执行`协程函数`
    task1 = asyncio.create_task(obj1)#创建任务对象,并且加入到执行列表里面,Task派生至Future,所以这里可以看成是future对象
    task2 = asyncio.create_task(obj2)#创建任务对象,并且加入到执行列表里面,Task派生至Future,所以这里可以看成是future对象
    l = [task1, task2]
    obj = asyncio.wait(l)       #生成`协程对象`,并不是真正执行`协程函数`
    done, pending = await obj   #真正执行协程函数,并且等待完成

asyncio.run(main())

#还可以如下方式调用
#loop = asyncio.get_event_loop()
#loop.run_until_complete(main())

#还可以如下方式调用
#loop = asyncio.get_event_loop()
#t = loop.create_task(main())
#loop.run_until_complete(t)

#还可以如下方式调用,这种方式程序永远不会退出
#loop = asyncio.get_event_loop()
#loop.create_task(main())
#loop.run_forever()

exit()

#==========================================================================
#==========================================================================

若干参考资料:

asyncio源码: Anaconda3/Lib/asyncio/*.py 例如futures.py,tasks.py,coroutines.py,events.py,runners.py等

https://docs.python.org/zh-cn/3/library/asyncio-task.html  《协程与任务》
https://zhuanlan.zhihu.com/p/27258289     《Python Async/Await入门指南》
https://www.cnblogs.com/pigerhan/p/3474217.html 《两种IO模式:Proactor与Reactor模式》
https://www.cnblogs.com/harelion/p/8496360.html 《Python 3.5中async/await的工作机制》

一个不错的数字货币量化交易框架

量化交易系统整体架构:

 

OKEX以太坊合约随笔

OKEX上的ETH合约是反向合约,计价货币为USD, 结算货币为ETH, 每张合约价值10USD,  如图:


下面是些简单的公式:

开仓数量eth = 开仓合约数量(张) * 合约价值usd / 开仓价格(usd)

开仓保证金eth = 开仓数量eth / 杠杆倍数

第二弹(Dotfuscator_x86)

又有挺久没有更新了,这次发的是一个32位windows下x86指令集的扭曲加密小工具,这个小工具是2008年做的,当时因为需要给开发的windows驱动进行一些防护,防止其他人逆向,当时能给驱动加壳的软件还不是很多,比较厉害的就是刘涛涛的扭曲加密,不过因为各种原因最后在高人的指点下自己弄了个简单的代码扭曲加密小工具用于驱动代码的保护,虽然远远谈不上完美,但是勉强也能用,呵呵。 


因为年代久远有些细节也记不清楚了,基本思路就是比如将jmp会替成 jnz xxx jz xxx, call变成push xxx,jmp target这种代码,然后可以通过多次循环变换将生成的代码进一步进行分解变换以提高代码扭曲的程度。需要扭曲加密的代码块在编译前用宏  START_MUTATE() 和 END_MUTATE() 包裹住。比如:

证券从业法律法规数字总结

一、公司法

1.有限责任公司由50个以下股东共同出资设立。

2.预先核准的公司名称保留期为6个月。

3.公司担保的特殊规定:在议决表决时,被担保人不得参加表决。决议的表决由出席会议的其他股东所持表决权的过半数通过,方为有效。

4.有限责任公司注册资本的最低限额为:

  (1)以生产经营为主的公司的注册资本为人民币50万元。

«1234567»

Powered By Z-Blog 2.2 Prism Build 140101

Copyright phonegap.me Rights Reserved.