python 硬件模拟_如何编写一个硬件模拟器？

手机登录帐号如何避免封号？？？

用手机登录的不外分为以下两种情况，

1：自己准备大量的手机，几十到几百部

2：使用模拟器 。

那个成本更低呢？？仁者见仁，智者见智，我们先分析下他们的优缺点。

大量手机，二手手机我们按照最便宜的，300 一个，我是指3G运行内存的，1G内存的基本不能用了的，

10台就是3000 ，100台就是3万块 ，而且还需要云控平台，这个平台价格也不菲 而且不稳定。

那么如果用模拟器呢？一台高配点的电脑，可以同时开16个模拟器。这种电脑主机只需要2000多块，

我个人更倾向用模拟器 。但是模拟器有一个致命的缺点 ，无法模拟出来真实手机。

用鲁大师检测如下：

各种参数和真实手机参数是不一样的，这样的模拟器，你拿来登录帐号，养号，一旦违规非常容易封号，

如果你用模拟器，需要借助硬件模拟大师，进行硬件级虚拟，

经过硬件虚拟后的模拟器，完全达到了 和真机一模一样的效果，而且可以随意模拟各种手机，

支持市面所有主流的手机 ，这个也是我在养号，包括抖音，快手，其他各种平台养号使用的一个工具。

如果采用几十台手机，管理起来特别麻烦，需要借助群控软件，群控软件也是一笔价格不菲的开支，比如100控的云控软件，

要价上万 ，屌丝的我们伤不起啊 ！

而且一台真实手机，如果没有好的硬件模拟工具，一旦曾经封过号的手机，再登录，或是切换帐号登录，是非常容易封号的。

我通常是模拟器配合硬件虚拟，然后搭配自动化脚本来操作。只要过了 root 检测，机器硬件信息检测，就有无数的手机可以使用

有这方面需求的可以参考下图找我交流

type exec_opts =

{ bound: int

; skip_throw: bool

; function_summaries: bool

; entry_points: string list

; globals: Domain_used_globals.r }

module Make (Dom : Domain_intf.Dom) = struct

module Stack : sig

type t

type as_inlined_location = t [@@deriving compare, sexp_of]

val empty : t

val push_call :

Llair.func Llair.call -> bound:int -> Dom.from_call -> t -> t option

val pop_return : t -> (Dom.from_call * Llair.jump * t) option

val pop_throw :

t

-> init:'a

-> unwind:

( Llair.Reg.t list

-> Llair.Reg.Set.t

-> Dom.from_call

-> 'a

-> 'a)

-> (Dom.from_call * Llair.jump * t * 'a) option

end = struct

type t =

| Return of

{ recursive: bool (** return from a possibly-recursive call *)

; dst: Llair.Jump.t

; formals: Llair.Reg.t list

; locals: Llair.Reg.Set.t

; from_call: Dom.from_call

; stk: t }

| Throw of Llair.Jump.t * t

| Empty

[@@deriving sexp_of]

type as_inlined_location = t [@@deriving sexp_of]

(* Treat a stack as a code location in a hypothetical expansion of the

program where all non-recursive functions have been completely

inlined. In particular, this means to compare stacks as if all Return

frames for recursive calls had been removed. Additionally, the

from_call info in Return frames is ignored. *)

let rec compare_as_inlined_location x y =

if x == y then 0

else

match (x, y) with

| Return {recursive= true; stk= x}, y

|x, Return {recursive= true; stk= y} ->

compare_as_inlined_location x y

| Return {dst= j; stk= x}, Return {dst= k; stk= y} -> (

match Llair.Jump.compare j k with

| 0 -> compare_as_inlined_location x y

| n -> n )

| Return _, _ -> -1

| _, Return _ -> 1

| Throw (j, x), Throw (k, y) -> (

match Llair.Jump.compare j k with

| 0 -> compare_as_inlined_location x y

| n -> n )

| Throw _, _ -> -1

| _, Throw _ -> 1

| Empty, Empty -> 0