Andoir Gradle出现Error:Cause: unable to find valid certification path to requested target的解决方法，亲测有效系列

前言（废话）

由于公司出现题述问题，导致严重影响本人学习Android，所以费劲心思终于找到了国内的镜像。

解决方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
buildscript {
  repositories {
    maven { url 'http://maven.aliyun.com/nexus/content/repositories/google' }
    maven { url 'http://maven.aliyun.com/nexus/content/repositories/jcenter'}
  }
  dependencies {
    classpath 'com.android.tools.build:gradle:3.6.1'
    // NOTE: Do not place your application dependencies here; they belong
    // in the individual module build.gradle files
  }
}
allprojects {
  repositories {
//    google()
//    jcenter()
    maven { url 'http://maven.aliyun.com/nexus/content/repositories/google' }
    maven { url 'http://maven.aliyun.com/nexus/content/repositories/jcenter'}
  }
}

修改build.gradle为以上代码部分，即可同步阿里的源，一般家里第一次同步不要走代理，后续可以走，尽量等到同步完成。当然如果你要像这样同步阿里源还是飞快的。

展开全文 >>

dex文件格式学习

什么是dex

dex是Android系统特有的可执行文件，具有应用的全部指令及运行时数据。
.class通过dx工具整合到一个dex,使得各个类都能互相通信，且减小占用的空间，使得结构更加紧凑。

class文件和dex的结构存在本质上的不同。
picture 1

为什么不使用class格式而采用dex格式
  1. dex整合所有的class文件压缩在classes.dex当中，所有的字符串常量可能会包含重复的，而整合在一起则可以最大化减少重复的字符串等信息。
  2. 如果一个class文件依赖另一个class文件则需要加载另一个class文件，这就会造成I/O操作，因为一次性把所有class文件加载，可以使得I/O操作减少。
字节序

计算机硬件有两种储存数据的方式：大端字节序（big endian）和小端字节序（little endian）。

dex格式存储采用的是小端字节序,比如一个16进制数0x2211,大端字节序跟该数字一致，采用高位字节在前低位字节在后。

而小端字节序则与大端字节序相反，采用高位字节在后低位字节在前，则该数位0x1122

同理0x987654其小端字节序写做:0x456789,即人一般读数是按大端字节序读取，而dex的读数是按小端字节序来读取的，其实这一块会由外部设备进行自动转换方便人的阅读，理解即可。

信息描述规则
数据类型描述（Type Descriptor）

数据类型描述说的是用字符串表示不同的数据类型。在这方面，Dex和Class文件格式没有区别。

  1. 原始数据类型对应的字符串描述为”B”,”C”,”D”,”F”,”I”,”J”,”S”,”Z”，它们分别对应的
    Java类型为byte,char,double,float,int,long,short,boolean。
  2. “V”：表示void，不过只能用于表示函数的返回值类型。
  3. 引用数据类型的格式为”LClassName;”。此处的ClassName为对应类的全路径名。
  4. 数组用”[其他类型的描述名”来表示。Dex文件最多支持255维数组。
简短描述（Shorty Descriptor）

用来描述函数的参数和返回值信息，类似Class文件格式的MethodDescriptor。不过，Shorty Descriptor比MethodDescriptor要抠，省略了好些个字符。

定义ShortyDescriptor的描述规则，箭头后面是规则的组成：

  1. ShortyDescriptor → ShortyReturnType (ShortyFieldType)*
  2. ()在规则中表示一个Group，*号表示这个Group可以有0或多个

定义ShortyReturnType的描述规则：
ShortyReturnType → ‘V’ | ShortyFieldType
ShortyFieldType → ‘Z’ | ‘B’ | ‘S’ |’C’ | ‘I’ | ‘J’ | ‘F’ | ‘D’ |’L’
定义ShortyFieldType的描述规则，注意，引用类型统一用”L”表示即可

ShortyDescriptor是”返回值类型”+”参数类型”，如果有参数就会带参数类型，没有参数就只有返回值类型。

在ShortyDescriptor的ShortyFieldType中，引用类型只需要用”L”表示，显然，ShortyDescriptor对于那些参数或返回值类型为引用类型的函数将无法区分。不过没关系，Dex中还会提供其他数据来指明参数或返回值的具体类型。这种做法的原因其实还是为了减少字符串的使用。

DexHeader
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
 * Direct-mapped "header_item" struct.
 */
struct DexHeader {
    u1  magic[8];           /* includes version number */
    u4  checksum;           /* adler32 checksum */
    u1  signature[kSHA1DigestLen]; /* SHA-1 hash */
    u4  fileSize;           /* length of entire file */
    u4  headerSize;         /* offset to start of next section */
    u4  endianTag;
    u4  linkSize; // link_data，理论上是预留区域，没有特别的作用。
    u4  linkOff;
    u4  mapOff;
    u4  stringIdsSize; // string_ids数组，元素类型为string_id_item，它存储和字符串相关的信息。
    u4  stringIdsOff;
    u4  typeIdsSize; // type_ids数组，元素类型为type_id_item。存储类型相关的信息（由TypeDescriptor描述）。
    u4  typeIdsOff; 
    u4  protoIdsSize; // proto_ids数组,主要功能就是用于描述成员函数的参数、返回值类型，同时包含ShortyDescriptor信息
    u4  protoIdsOff;
    u4  fieldIdsSize; // field_ids数组，元素类型为field_id_item，存储成员变量信息，包括变量名、类型等。
    u4  fieldIdsOff;
    u4  methodIdsSize; // method_ids数组，元素类型为method_id_item，存储成员函数信息包括函数名、参数和返回值类型等。
    u4  methodIdsOff;
    u4  classDefsSize; // class_defs数组，元素类型为class_def_item，存储类的信息。
    u4  classDefsOff;
    u4  dataSize; // data区域，Dex文件重要的数据内容都存在data区域里。一些数据结构会通过如xx_off这样的成员变量指向文件的某个位置，从该位置开始，存储了对应数据结构的内容，而xx_off的位置一般落在data区域里。
    u4  dataOff;
};

注：邓凡平先生主要把dex_header分成
picture 2
上面的注释也主要围绕这个分发加注

header_item

header_item是一个二进制数据集合，邓凡平先生通过编程语言还原了其结构
picture 3

magic: 取值必须是字符串“dex\n035\0”，或者byte数组{0x640x650x780x0a 0x300x330x350x00}

checksum: 文件内容的校验和。不包括magic和checksum自己。该字段的内容用于检查文件是否损坏。

signature: 签名信息，不包括magic、checksum和signature。该字段的内容用于检查文件是否被篡改。

file_size: 整个文件的长度，单位为字节，包括所有内容。

header_size: 默认是0x70个字节。

endian_tag: 表示文件内容应该按什么字节序来处理。默认取值为0x12345678，Little Endian格式。如果为Big Endian时，该字段取值为0x78563412。

xxx_id_item: 包括string_id_item、type_id_item、proto_id_item、field_id_item和method_id_item这五种数据结构，它们对应为string_ids、type_ids、proto_ids、field_ids和method_ids数组元素的数据类型。

picture 4

string_data_item: utf16_size是字符串中字符的个数。Dex文件的字符串采用了变种的UTF8格式，对于英文字符和数字字符而言，都只占一个字节。data是字符串对应的内容。

string_id_item: 类似Class文件的CONSTANT_String类型，它只有一个成员。

string_data_off: 用于指明string_data_item位于文件的位置，也就是索引。

type_id_item: descriptor_idx是指向string_ids的索引。

field_id_item: class_idx和type_idx是指向type_ids的索引，而name_idx是指向string_ids的索引。

method_id_item: class_idx是指向type_ids的索引，proto_idx是指向proto_ids的索引，name_idx是指向string_ids的索引。

proto_id_item: shorty_idx是指向string_ids的索引，return_type_idx是指向type_ids的索引，如果parameters_off不为0，则文件对应的地方存储类型为type_list的结构，用于描述函数参数的类型。

type_item: type_idx是指向type_ids的索引。

type_list: size表示list数组的个数，而list数组元素类型为type_item。函数的每一个参数都对应一个type_item元素。

于proto_id_item: 首先，它的成员域shorty_idx（也就是ShortyDescriptor字符串）已经描述了参数和返回值的类型，但这只是简单描述，比如所有引用类型都用”L”统一表示，所以ShortyDescriptor肯定无法完整描述那种参数或者返回值类型为引用类型的函数。为解决此问题，proto_id_item中的return_type_idx用来描述返回值的数据类型，而参数的类型则通过parameters_off域（如果取值不为0，则表示该函数有参数）指向一个type_list。这个type_list为每个参数都存储了对应的数据类型（通过type_item中的type_idx来索引type_ids中的元素）。

class_def:
picture 5
class_idx：指向type_ids，代表本类的类型。

superclass_idx：指向type_ids，代表基类类型，如果没有基类则取值为NO_INDEX（值为-1）。

interfaces_off：如果本类实现了某些接口，则interfaces_off指向文件对应位置，那里存储了一个type_list。该type_list的list数组存储了每一个接口类的type_idx索引（参考图3-5和对应的解释）。

source_file_idx：指向string_ids，该类对应的源文件名。

annotations_off：存储和注解有关的信息。

class_data_off：指向文件对应位置，那里将存储更细节的信息，由class_data_item类型来描述。

static_values_off：存储用来初始化类的静态变量的值，静态变量如果没有显示设置初值的话，默认是0或者null。如果有初值的话，初值信息就存储在文件static_values_off的地方，对应的数据结构名为encoded_array_item

picture 6
一个类的成员变量、成员函数等信息则是通过class_data_off域指向一个名为class_data_item结构体来描述的。

static_fields：类的静态成员信息，元素类型为encoded_field。
instance_fields：类的非静态成员信息，元素类型为encoded_field。
direct_methods：非虚函数信息，元素类型为encoded_method。
virtual_methods：虚函数信息，元素类型为encoded_method。

encoded_field和encoded_method用于描述类的成员变量和成员函数的信息。

encoded_field：field_idx_diff指向field_ids。注意这里是field_idx_diff，它表示除数组里第一个元素的field_idx_diff取值为索引值，该数组后续元素field_idx_diff取值为和前一个索引值的差。access_flags表示成员域的访问标志

encoded_method：method_idx_diff指向method_ids。diff的含义与field_idx_diff一样。access_flags表示该函数的访问标志，code_off指向文件对应位置处，那里有一个类型为code_item的结构体，code_item类似于Class文件的Code属性。

access_flags取值范围

picture 7
picture 8

code_item

dex格式当中，我们需要了解的重中之重，因为函数抽取实际上就是把code_item进行抽空（置0）的方式实现的。
picture 9

registers_size：此函数需要用到的寄存器个数。

ins_size：输入参数所占空间，以双字节为单位。

outs_size：该函数表示内部调用其他函数时，所需参数占用的空间。同样以双字节为单位。

insns_size和insns数组：指令码数组的长度和指令码的内容。Dex文件格式中JVM指令码长度为2个字节，而Class文件中JVM指令码长度为1个字节。

tries_size和tries数组：如果该函数内部有try语句块，则tries_size和tries数组用于描述try语句块相关的信息。注意，tries数组是可选项，如果tries_size为0，则此code_item不包含tries数组。

padding：用于将tries数组（如果有，并且insns_size是奇数长度的话）进行4字节对齐。

handlers：catch语句对应的内容，也是可选项。如果tries_size不为零才有handlers域。

padding则是需要对齐的时候才存在

展开全文 >>

爬虫遇到的问题

nodejs 的 express框架post总是接收不到参数

一般我都会把data转成json再传给nodejs服务，结果总是获取不到参数，脑壳痛，这里记录一下。
picture 1

首先发送请求的时候，要给定Content-Type为application/jsongi

注意app.use那里，指定了从header的content-type为application/json的请求获取参数，这里的limit是为了扩大接收的参数大小，这里我随意写了一个足够大的大小。
picture 2

如果不写limit会发生什么情况呢？
picture 3

会出现请求体过大导致报错的情况。

究其原因是因为nodejs 做为服务器，在传输内容或者上传文件时，系统默认大小为100kb。

展开全文 >>

网络的一些知识（持续更新）

nat

通常小型企业或者是学校单位大多仅会有一条对外的联机，然后全公司/学校内的计算机全部透过这条联机连到因特网上。此时我们就得要使用P分享器来让这一条对外联机分享给所有的公司内部员工使用。那么Linux能不能达到此一IP分享的功能呢?当然可以，就是透过NAT服务即可达成这项任务了!
在这种环境中，由于Linux作为一个内/外分离的实体，因此网络流量会比较大一点。此时Linux主机的网络卡就需要比较好些的配备。其他的CPU、RAM、硬盘等等的影响就小很多。事实上，单利用Linux作为NAT’主机来分享P是很不智的～因为PC的耗电能力比P分享器要大的多～

展开全文 >>

Python工具函数 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

def pb2jb(byte_arr):
    """
    python字节码转java字节码
    :param byte_arr:
    :return:
    """
    return [int(i) - 256 if int(i) > 127 else int(i) for i in byte_arr]


def jb2pb(byte_arr):
    """
    java 字节码转python字节码
    :return:
    """
    return [i + 256 if i < 0 else i for i in byte_arr]


def hex2jb(hex_str):
    """
    十六进制数据转java字节码
    eg:
        hex_str = "5f 3c f2 81 c8 0f 88 89 c7 b1 99 77 58 c5 4c 04"
    :return:
    """
    return [int(i, 16) - 256 if int(i, 16) > 127 else int(i, 16) for i in hex_str.split(" ")]


def hex2pb(hex_str):
    """
    十六进制数据转python字节码
    eg:
        hex_str = "5f 3c f2 81 c8 0f 88 89 c7 b1 99 77 58 c5 4c 04"
    :return:
    """
    return [int(i, 16) for i in hex_str.split(" ")]


def pb2str(byte_arr, encoding="utf-8"):
    """
    python字节码转str
    :return:
    """
    return bytes(byte_arr).decode(encoding)


def jb2str(byte_arr, encoding="utf-8"):
    """
    java字节码转str
    :return:
    """
    return bytes(jb2pb(byte_arr)).decode(encoding)


def hex2str(hex_str, encoding="utf-8"):
    """
    hex转str
    :param hex_str: "2c 22 70 61 79 63 68 65 63 6b 6d 6f 64 65 22 3a"
    :param encoding:
    :return:
    """
    return bytes(hex2pb(hex_str)).decode(encoding)

展开全文 >>

ob混淆AST

ob混淆的特征

大数组+位移函数+解密函数，多个位置多次调用解密函数。
picture 1

写AST

picture 2
自执行函数如果带参数的都会有个加载器，我们看看兄弟节点有啥用吧。
picture 3
这些setCookie这类的只是为某个obj的属性。只需观察这些函数里面有没有啥实参。

picture 4

对这个自执行的函数来说，全局的变量只有这么两个_0x1032, 0x1a7,就围绕这两个看看。
picture 5
这两个实参到这个函数里是_0x263f33,_0x270f13.

JS的函数的参数是啥传递。
picture 7

也就是说，如果不通过属性来修改对象的值，那都不影响实参！！！

我们来看看这个函数里有哪里用到了实参。

picture 1

只有这一处使用到了实参，数组实参只有加载器用到。

步进看看该函数是干啥的。
picture 2
执行的函数是加载器，加载器的作用也只是为了执行参数而已。也就是说，其实整段代码其实也就只有++那段有用。

picture 3
也就是这段。只需把函数名改为加载器的函数名，参数改为形参的参数名即可。

我们可以手动删掉，也可以通过AST来删。这里我们来用AST。

接下来我们来分析一下解密函数。
picture 4
我们看到用到_0x270f13只有一处。
再看rc4这函数是啥。
picture 5

保留了以上提到的，后面这里===undefine处，仅仅只需保留
picture 6
该处即可。

控制流平坦化

picture 7
像这种通过switch和while来混淆代码的执行顺序，既是控制流平坦化，这类的代码比较麻烦，不过可以看看极验那块的代码，那块的控制流平坦化比ob混淆的要好些，这个相对简单，直接附上代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
const decode_while = {
    WhileStatement(path) {
        let {test, body} = path.node;
        let swithchNode = body.body[0];
        if (!types.isUnaryExpression(test) || !types.isSwitchStatement(swithchNode)) return;
        let {discriminant, cases} = swithchNode;
        if (!types.isMemberExpression(discriminant) || !types.isUpdateExpression(discriminant.property)) return;
        let arrayName = discriminant.object.name;
        let per_bro_node = path.getAllPrevSiblings();
        let array = []
        per_bro_node.forEach(per_node => {
            const {declarations} = per_node.node;
            let {id, init} = declarations[0];
            if (arrayName === id.name) {
                array = init.callee.object.value.split('|');
            }
            per_node.remove();
        });

        let replace_body = [];
        array.forEach(index => {
                let case_body = cases[index].consequent;
                if (types.isContinueStatement(case_body[case_body.length - 1])) {
                    case_body.pop();
                }
            replace_body = replace_body.concat(case_body);
            }
        );
        path.replaceInline(replace_body);
    }
}

traverse(ast, decode_while);

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
/***********************************************************
 ob混淆这类的特征是大数组加位移函数加解密函数
 ***********************************************************/


const parser = require("@babel/parser");
const traverse = require("@babel/traverse").default;
const types = require("@babel/types");
const generator = require("@babel/generator").default;
const fs = require('fs');
decode_file = 'D:\\huangsheng\\self\\js_workspace\\node_workspace\\js_parse\\bitstamp\\js\\result.js'
var jscode = fs.readFileSync('D:\\huangsheng\\self\\js_workspace\\node_workspace\\js_parse\\bitstamp\\js\\source.js', "utf-8", function (err, data) {
    if (err) {
        console.log(err);
    } else {
        code = data.toString();
    }
});
let ast = parser.parse(jscode)

/***********************************************************
 NumericLiteral ---> Literal
 StringLiteral  ---> Literal
 用于处理已十六进制显示的字符串或者数值
 ***********************************************************/
const delete_extra =
    {
        "NumericLiteral|StringLiteral": function (path) {
            delete path.node.extra;
        },
    }

traverse(ast, delete_extra);

// 删除加载器下的多余的节点
const decode_str = {
    VariableDeclarator(path) {
        let {id, init} = path.node;
        if (!types.isArrayExpression(init) || init.elements.length == 0) return;
        let code = path.toString();

        let second_sibling = path.parentPath.getNextSibling(); //获取移位函数节点
        let third_sibling = second_sibling.getNextSibling();   //获取解密函数节点

        // 开始检测特征
        if (!types.isExpressionStatement(second_sibling) || !types.isVariableDeclaration(third_sibling)) return;
        let expression = second_sibling.get('expression');
        if (!expression.isCallExpression()) return;

        let {callee, arguments} = expression.node;
        if (arguments.length !== 2 ||
            !types.isFunctionExpression(callee) ||
            !types.isIdentifier(arguments[0], {name: id.name}) ||
            !types.isNumericLiteral(arguments[1])
        ) return;

        let {declarations} = third_sibling.node;

        if (!declarations ||
            declarations.length !== 1 ||
            !types.isFunctionExpression(declarations[0].init)
        ) return;

        // 检测结束
        let sourceSecond = second_sibling.toString()
        let thirdFuncName = third_sibling.node.declarations[0].id.name;
        // 开始处理移位函数
        if (sourceSecond.indexOf('removeCookie') !== -1) {
            let second_arg_node = callee.params[1];
            let body = callee.body.body;
            let call_fun = body[0].declarations[0].id;  //解密函数的函数名，用于遍历其作用域
            body.pop();
            body.pop();
            body.push(types.ExpressionStatement(types.UpdateExpression("++", second_arg_node)));
            body.push(types.ExpressionStatement(types.callExpression(call_fun, [second_arg_node])));

            // 位移函数处理结束

            // 处理解密函数开始
            let end = third_sibling.node.end; //防止遍历函数体里的调用
            third_sibling.traverse({
                AssignmentExpression(path_) {
                    let left = path_.get('left');
                    let leftCode = left.toString()
                    let right = path_.get('right');
                    let rightCode = right.toString();
                    if (rightCode.indexOf(thirdFuncName) === -1 || rightCode.indexOf(leftCode) === -1) return;
                    let ifParantNode = path_.findParent(g => {
                        return g.isIfStatement();
                    });
                    ifParantNode && ifParantNode.replaceWith(path_.node);
                }
            });
            code += ';!' + second_sibling.toString() + third_sibling.toString();
            //eval到本地环境
            eval(code);

            const binding = third_sibling.scope.getBinding(thirdFuncName);
            if (!binding || binding.constantViolations.length > 0) return;

            let can_removed = true;
            for (const temp of binding.referencePaths) {
                // 为了处理调用解密函数处，修改为常量，故不能调用到解密函数中
                if (temp.node.start < end) {
                    continue;
                }
                let callPath = temp.findParent(p => {
                    return p.isCallExpression();
                });
                try {
                    let fun_value = eval(callPath.toString());
                    console.log('del with fun:', callPath.toString(), '  is value:', fun_value);
                    callPath && callPath.replaceWith(types.valueToNode(fun_value));
                } catch (e) {
                    can_removed = false;
                }
            }
            if (can_removed) {
                path.parentPath.remove();
                second_sibling.remove();
                third_sibling.remove();
            }
        }
    }
}

traverse(ast, decode_str);

// 处理BinaryExpression
const decode_binary = {
    BinaryExpression(path) {
        const {confident, value} = path.evaluate();
        if (Infinity === value) return;
        confident && path.replaceWith(types.valueToNode(value));
    }
}

traverse(ast, decode_binary);

// 处理控制流平坦化
const decode_while = {
    WhileStatement(path) {
        let {test, body} = path.node;
        let swithchNode = body.body[0];
        if (!types.isUnaryExpression(test) || !types.isSwitchStatement(swithchNode)) return;
        let {discriminant, cases} = swithchNode;
        if (!types.isMemberExpression(discriminant) || !types.isUpdateExpression(discriminant.property)) return;
        let arrayName = discriminant.object.name;
        let per_bro_node = path.getAllPrevSiblings();
        let array = []
        per_bro_node.forEach(per_node => {
            const {declarations} = per_node.node;
            let {id, init} = declarations[0];
            if (arrayName === id.name) {
                array = init.callee.object.value.split('|');
            }
            per_node.remove();
        });

        let replace_body = [];
        array.forEach(index => {
                let case_body = cases[index].consequent;
                if (types.isContinueStatement(case_body[case_body.length - 1])) {
                    case_body.pop();
                }
            replace_body = replace_body.concat(case_body);
            }
        );
        path.replaceInline(replace_body);
    }
}

traverse(ast, decode_while);

/************************************
 处理完毕，生成新代码
 *************************************/
let {code} = generator(ast);
fs.writeFile(decode_file, code, (err) => {
});

展开全文 >>

Anroid学习笔记

课程里用到的Linux命令

telnet ip port:该命令用于检测该ip的这个端口是否已经开放。

curl ip.sb: 该命令用于查询本机当前IP是多少.

strace: 用于诊断和调试Linux用户空间syscall跟踪器，可以用来监控用户空间进程和内核的交互。简单来说就是看系统调用的整个过程。

lsof: 英文释义为list open files,是一个列出当前系统打开文件的工具

netstat -aple（或者用-tuulp） | grep procese_name: 用于查看某个进程其监听端口

du -h *:查看当前文件夹的每个文件的大小

scp /path/filename username@servername:/path : 通过ssh发送文件

系统调用

是指允许在用户空间的程序向操作系统内核请求需要更高权限允许的服务，系统调用提供用户程序与操作系统内核之间的接口。

Java的new File()写文件的原理

Java本质上调用了C/C++来完成。写完之后是一个art.so,之后调用安卓调用bionic-c (kali是用glibc)封装的函数，bionic-c其实是调用了syscall到内核里去写文件

Android原生网络通信库
  1. 1 HttpClient
  2. 2 HttpURLConnection

HttpClient,现在已经没有人在用了。Android5时官方不再推荐其，Android6的SDK甚至直接去掉了，Android9时，Android更是彻底取消了对Apache HTTPClient的支持,Android开发官方推荐用HttpUrlConnection。
HttpUrlConnection, 虽然官方推荐，但是也很少有人用，跟python的urllib库一样，第三方库已经非常优秀了，所以多数人选择了第三方库。

Okhttp3

Okhttp是Square公司开源的网络请求框架，优秀到HttpUrlConnection的底层实现也是基于Okhttp。现在主流是okhttp3，由于okhttp3与okhttp4的api改动较大，所以它还是主流，较新版本都已经基于kotlin，okhttp3是目前最流行的android网络请求框架。

Retrofit2

一个基于okhttp框架的网络请求框架

Android-Async-Http

该库基于HttpClient,目前由于HttpClient的过时和作者不再更新，所以该库仅仅作为了解。

Volley

13年Google发布的一款基于HttpURLConnection的异步网络请求框架。特别适合数据量小，通信频繁的网络操作，有一定的使用量。

OkHttp3示例：

目标：搭建一个按钮，点击之后发送网络请求。

  1. 先是创建一个activity，这里我们可以使用main_activity.xml，在里面注册一个Button,只需在LinearLayout里创建button标签就行了。
    picture 2

  2. 接着就是在MainActivity.java里面创建Button对象，设定点击事件

    picture 3

  3. 先是测试一下，事件是否可以运行。
    picture 4
    能跑就行。

展开全文 >>

dLocal参数破解

该网站大致界面如下，我们需要获取的数据是红框里的数据，其加载为ajax.
picture 16

其参数为：

picture 14

经过检测，其必要的参数为

picture 15

token为非必须，这个就好办多了，一看token就是一个加密，既然加密参数不重要，这个最重要的就是找到data的规律。参数分析好了，看看请求头。
picture 13

这里我把cookie注释掉后请求返回了一串js,看来除了data还要处理cookie，我再测测看哪个cookie值是必须的。
picture 12

也就是说必须的cookie值是这个rbzid.
在看看不对的cookie返回的js

picture 11

也就是说我们要破解这一串js。

先用fiddler看看那串cookie在那里被设置的。

picture 9
这里没有，结果这个加密的链接这里就有设置这个cookie

picture 10

小目标又变了，变成如何生成这串url并发送请求。先看第一个请求返回的html

picture 8

看来不怎么多，搞得都不想写ast了。不过还是试试看。

把unicode转成字母

picture 7

像这种的如果是StringLiteral直接把它的extra删掉就好。但是这种是RegExpLiteral这种需要把它运行一遍获取到真正的值时替换原节点即可，后来我发现直接转的话跟下一个参数没有空格导致报错，能力不行，自己手动加空格。

picture 6

效果如上。

把16进制转成10进制

picture 5

可以看到显示的是raw,而10进制则为上面的value，我们可以把extra删掉这样就能显示value了。

picture 4

效果如上。

呼，做不是程序解决的活真是体力活。后面终于弄好了，开始解决逻辑的东西了~
我们要考虑的是自执行的函数，TOSS这个对象就不要管了。
先解决这种xxx.xx(number)这种形式的代码。
我这里先解决var h = T0SS;这类多余代码。

这里可以采用path.scope.rename(oldStr, NewStr)这个方法，直接替换h为T0SS就可以解决了。

然后就出现了多余的代码var T0SS = T0SS;我们可以通过一系列判断之后通过path.remove()删除掉相应节点。

接下来进入正题，解决xxx.xx(number)这种形式的代码。
碰到这种我们肯定要有T0SS以及它的相应函数，所以这一片代码要扣过来。这部分不讲了，直接上代码。

picture 2

执行完以上的AST我们的待破解的代码就清晰很多了，这时候就需要补环境了。缺啥补啥，需要注意的是最后一行它的window.rbzns里的参数是动态的，所以我们也要考虑改成动态的。比如说碰到document.createElement这些。看看它的代码之间的关联，如果只是为HTML创建标签的话，直接删掉就好了。

picture 1

可以考虑像我这样写，这样就会成动态的了。本篇只是在记录自己工作上碰到的一个网站，感觉用AST合适就记录下来了。大家可以练练手哦~

展开全文 >>

C零碎知识点（集中整理）

getchar()和putchar()

getchar:从文本流中读入下一个输入字符，并将其作为返回值返回，
putchar:打印一个字符。可以与printf交替调用，输出的次序与调用的次序一致。

C语言默认返回值类型

不显示声明返回类型，默认返回int类型。

C语言的函数参数传递

C语言的参数传递为值传递，即传递给函数的参数值存放在临时变量中。也就是说被调用函数不能直接修改主调函数中变量的值。
当把数组名用作参数时，传递给函数的值是数组起始元素的位置或地址——它并不复制数组元素本身。在被调用函数中，可以通过数组下标访问或修改数组元素的值。

如何让被调用函数修改主调函数的变量

主调函数传递地址（地址就是指向变量的指针），被调用函数也需要将对应的参数参数声明为指针类型，并通过它访问变量。

如何测量字符串长度

C语言使用<string.h>里提供的strlen(string)函数来实现返回特定字符串的长度，相当于python的len(obj)

C语言的字符和字符串的区别

字符说白了就是一个机器字符集对应的数字，是一个整数。
字符串实际上是一个字符数组，数组的最后一位为’\0’代表结束。
比如’x’和”x”实际上，”x”相当于[‘x’, ‘\0’]

C语言的枚举

枚举是一种常量类型，是一个常量整型值的列表。
例如：
enum boolean {NO, YES}没有显式说明的前提下，默认第一个是0，第二个是1，依次往上叠加。值也可以是’a’之类的可以转为数字的char.不同枚举的值中的名字必须不同，不同的名字的值可以相同

展开全文 >>

头条newsJS逆向

听说头条更新了，而且我下个周确定入职，所以想练练JS逆向，好久不搞JS逆向这一块了，话不多说，搞起。

参数对比

picture 1

picture 2

picture 3

从以上三图可知我们需要的参数是max_behot_time(时间戳)、as、cp、_signature

寻找加密处

  1. as、cp
    全局搜索as:即可搜到as和cp，打个断点下拉就能看到了~
    picture 4

我们可以看到as和cp来自e,而这个e是下图
picture 5

找到a()
picture 7

进入到a之后看看这个o是啥玩意。
picture 8

再步进C
picture 9
这个是是在某个自执行函数里面的，我们一般把这个自执行抠出来。报错的地方不影响的话直接去掉即可。
picture 10
2. _signature
这个参数是最让一般人头疼的，我们来慢慢的解决它。
picture 11
全局搜索找到这个地方。找到p.calcSignature所代表的的函数p()
picture 12
看到那么多location、window就知道这个东西有进行环境检测。能写死先写死。

picture 13
这个参数是除了_signature之外所有参数拼接而成的url："https://www.toutiao.com/toutiao/api/pc/feed/?max_behot_time=1595566720&category=__all__&utm_source=toutiao&widen=1&tadrequire=true&as=A1153FE1EB50763&cp=5F1BB08776134E1"

window.byted_acrawler.sign的方法实际上是在另一个文件里
picture 14

这个文件存在着一个大大的自执行函数TAC，这个似乎是头条核心的加密了，我继续整整。

picture 15
先看看这个window.byted_acrawler这里有个init函数，函数里面的vm就是TAC所在的文件，那我们这边大胆假设一下，这个init的执行之后才有了sign。

扣出p并把TAC整个扣出放入p内。构建参数，跑一遍看看。
picture 17
是不是给抓包出来的参数对比出来的不一样？目测环境问题。把代码扣出来放浏览器跑跑。

picture 16

果然是！那问题就是TAC文件里面有环境检测了。看看哪里有window或navigator一般检测就检测这两。
picture 18
我们看到这里的v是global对象，很有可能通过这个进行了检测。

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一只从Java到爬虫未来将会到安全的软件工程师。