git的使用

2020-07-19

git的使用

git的来由

git是一个分布式版本控制系统，其实由Linux之父林纳斯创建，其质量如何不言而喻。其开发的目的是为了更好的管理和开发Linux的内核。git在本地磁盘上保存着所有当前项目的历史更新，处理速度快；git的绝大多数操作都只需要访问本地文件和资源，不用实时联网。

git的三种工作区域

本地仓库

每个git init之后都会产生这样一个文件夹.git,其内部是这样的

hooks: 里面存放这,看下图可以知道，这些是一些shell脚本

info: 仓库的一些信息
logs: 日志信息（废话了）
objects: 存放所有的git对象

refs：
- heads：保存当前最新的一次提交的哈希值
- tags: 空的，估计我最近写博客没有啥标签

工作区

用户操作目录,大白话就是你平时存放项目代码的地方

暂存区

说白了，你每次add之后都会先提交到暂存区.

git的三种状态

committed(已提交)

该文件已经被保存在本地仓库中

modified(已修改)

修改某文件，但是还没提交

staged(已暂存)

把已修改的文件放在下次提交时要保存的清单当中

git的分支

git中的分支，本质上是一个commit对象的可变指针。
git会使用master作为分支的默认名字，在若干次提交后其实已经存在了一个指向最后一次提交对象的master分支，它在每次提交的时候都会自动向前移动。
git鼓励在工作中频繁使用分支与合并

git的标准工作流程

以上是git的最标准，最常见的工作流程。

对此的解释是：

master是一条稳定的分支，不会对这条分支轻易的修改，如线上有bug在master分支分出hotfix分支用来解决bug。当有新的需求时会再开一条分支develop,开发人员通过这个分支再分出自己的feature分支，开发完成之后合并回develop，测试从develop分支分出release进行测试，测试没问题即合并回master分支。

git的基本操作

配置用户名和邮箱

git config --global user.name "your username"
git config --global user.email "your email"

创建版本库

创建项目目录
1
2
mkdir testgit
cd test
初始化目录
git init

查看仓库状态

git status

添加到暂存区

git add fileA fileB fileC ...

提交到本地仓库

git commit -m 注释信息

查看修改内容

工作区 git diff
仓库 git file

查看版本

git log --pretty=oneline
git log --pretty=short
git log --pretty=full
git log --pretty=fuller

以上是简单模式，基本够用了，不行的话自己定制
git log --pretty=format:"%h - %an, %ar : %s"

版本回退

回到上一个版本
git reset --hard HEAD^
使用git reset 只能回退本地分支：

丢弃工作区的修改(撤回)
git checkout -- file

删除文件

git rm file git commit -m 注释

查看当前分支

git branch (-a)

新建分支

git branch develop
新建分支之后并没有自动切换过去，需要主动切换分支

切换分支

git checkout develop

新建并切换分支

git checkout -b feature
该操作相当于前面两步骤合在一起执行。

删除分支

git branch -d feature
需要注意的一点是当前所在分支无法被删除

合并分支

git checkout develop && git merge feature
以上的命令解释为：把feature合并到develop分支

git和远程服务器的交互

添加远程服务器

git remote add xx.git(别名) host/xxx.git
示例：
git remote add dcmsStatics4.5git(别名）http://gitlab.cephchina.com/ccod_project/dcmsstatics4-5git.git

查看远程服务器的相关信息

git remote -v
git remote show xx.git

重命名远程仓库信息

git remote rename demo test

删除远程仓库

git remote rm test

注：第一次提交的时候加上-u 可以使得本地的master和远程的新的master关联起来

本地master推送到远程仓库的master

git push xx.git master

从远程仓库获取数据

git fetch origin develop 获取远程仓库的数据至.git目录，但并不merge本地的分支
git merge origin/develop 把获取远程仓库的数据手工merge到当前分支
git pull origin develop 获取远程仓库的数据，并merge至当前分支，相当于以上两步

合并两个不同项目

git merge 项目名 --allow-unrelated-histories

跟踪分支

从远程分支checkout出来的本地分支叫做跟踪分支，跟踪分支是一种和远程分支有直接联系的本地分支。跟踪分支里使用git push会自行判断要把推送发往哪个服务器

在git clone仓库下来之后会自动创建一个master分支来跟踪origin/master。所以一开始我们就可以使用git push和git pull

从远程库克隆

从SVN克隆git svn clone 地址
从git远程库上克隆git clone 地址

在本地创建和远程分支对应的分支

git checkout -b branch-name origin/branch-name

tag(标签)

git的标签用于给分支做标记

创建标签

轻量级标签

git tag <tag-name> commit id

带说明的标签

1 2	git tag -a <tag-name> commit id git tag -m <msg> <tag-name> commit id

带签名的标签（GPG加密，需安装）

1 2	git tag -s <tag-name> commit id git tag -u <key-id> commit id

查看标签

1
2
3

git tag
git tag -n
git show <tag-name>

删除标签

git tag -d <tag-name>

共享标签

向上游版本库提交标签

1 2	git push origin <tag-name> git push origin --tags

删除远程版本库的标签
git push origin :tag2

git分支冲突

当不同分支在同一文件的同一部分都做了修改，则git就无法把两者都合在一起,发生冲突的时候git不会把代码提交。

查阅合并时出现冲突的文件

git status,git会在冲突的文件里加入标准的冲突解决标记，可以通过它们手工定位并解决这些冲突。
git log --graph --pretty=oneline --abbrev-commit也可以看到分支合并的情况

忽略特殊文件

创建和编写.gitgnore文件，编写不需要提交的文件，则提交之后这些文件将不会被提交
示例:

# 忽略所有 .a 结尾的文件
*.a
# 但 lib.a 除外
!lib.a
# 仅仅忽略项目根目录下的 TODO 文件，
/TODO
# 忽略 build/ 目录下的所有文件
build/
# 忽略 doc/notes.txt 
doc/*.txt

切换用户

查看当前配置用户

git config --list
修改配置：打开全局的.gitconfig文件，直接在文件当中修改。

git cherry-pick:新建分支并复制相应节点到分支上

git过滤掉调试语句

git describe:描述最近的标签

最后上一张图：

展开全文 >>

C程序设计语言

2020-07-16

C程序设计语言——指针

指针与指针变量

指针变量：
定义指针变量：类型名 *指针变量名

指针：

取地址运算符和取值运算符

如果需要获取某个变量的地址，可以使用取地址运算符（&）

例：
char *pa = &a;

如果需要访问指针变量指向的数据，可以使用取值运算符（*）

printf("%c, %d", *pa, *pb)

数组的地址

数组的地址为数组第一个元素所属的地址，又称为基地址

指针如何指向数组

直接使用指针指向数组的第一个元素即可

1
2
3

int a[] = {1,2,3,4,5};
int *p;
p = &a[0];

指针对数组的操作

当指针指向数组时，可以对指针变量进行加减运算。意思是获取数组的前或后几位元素。

图上是直接给p赋予地址，所以*p就直接获取的数组的第一个元素的值，这里即a.

这里再附张图对刚才的言论进行进一步论证。这里直接对p进行像数组这样的取值操作就是因为，我们刚开始&a[0]实际上是直接给p这个指针直接指向a这个数组。

当然了也可以通过直接对地址进行加减来获取数组的第几个元素。

这里的*(p+4)的解释为,p的值为地址值，刚才也说过可以对地址进行加减以此来获取数组的第n位元素，这里实际上就是对地址进行加减了，p+4获取的是第5个元素。

大家有注意到么？p我这里直接赋值a，获得的就是a数组的地址，原因在于我们p这里定义时为*p，所以如果直接赋值数组a的话将直接赋予数组的基地址。

无论指针是什么类型，都符合p+n为p指针对象的第n个地址

在计算p+n时，n将根据p指向的对象的长度按比例缩放，而p指向的对象的长度则取决于p的声明。例如，如果int类型占4个字节的存储空间，那么在int类型的计算当中对应的n将按4的倍数进行计算。

函数的参数指针的传递

我们知道C语言是值传递，值传递意味着我们每次传递都是一个副本，若想让我们传递的参数的影响离开调用函数也能保持修改有效，必须传递指针。

传递时传递了指针地址值的副本，或者说是拷贝了指针而没有拷贝具体的值。

但是每次位移都不针对原地址进行修改（实际上，传递的是一个字符数组，由于是数组其内存空间是连续的，其内部值是可以修改的，非数组的指针其指向内容无法修改，但是地址值不变），而是在这个副本的基础上进行修改。

也可以看到上图，进行++操作时，char类型的指针的地址的值加上了char类型的长度1，也就是说实际上我们在对指针进行加减操作时，实际上就是对地址值进行位移操作，位移的距离为+（或-）的数值乘以类型的长度，即这里的s++实际上就是s=s+1*1;

所以下面的这个函数

为什么能得出字符串的长度，实际上就是原字符的副本与另一个副本之间进行地址间的相减，比如我要计算char *s = "Hello";的长度,当s = “”时，即s++，s向右移了5位，此时的地址的值比刚传递过来的”Hello”的地址要多5 * 1 的值，则这个值减去初始的长度，则为5除以char的位数，即5 / 1；最终值就为5.

为了佐证这个观点，我又做了这个实验

s++之后，也就是其地址值加了4 * 1的地址值，那这个函数最终返回什么？答案是： 1.

即地址之间进行相应的加减之后得到的结果还得除以位数。

有效的指针运算

相同类型指针之间的赋值运算。
指针同整数之间的加法或减法运算。
指向相同数组中的两个元素的两个指针间的减法或比较运算。
将指针赋值为0或指针与0之间的比较运算。

其余的指针运算都是非法操作。

指针与数组的差别

1 2	char amessage[] = "Hello World!"; char *pmessage = "Hello World!";

以上是一个数组，和一个指针。

以上两者区别：

数组的值是可以修改，但是其始终指向同一个内存地址。
指针其初值指向一个字符串常量之后它可以被修改以指向其他地址，但如果试图进行修改字符串内容，结果是没有定义的。

指针数组

举个例子：
String[] a = {"1", "2"};
上面的a是什么类型？
字符串数组，实际上指针数组也是这么个意思，指针数组存的元素都是指针。

指针数组的初始化

与普通数组的初始化一样例如：

1
2
3

char *arrays[] = {
	"hi", "Hello"
};

指向函数的指针（函数指针）

函数作为参数时，不需要添加&来获取地址，与数组一样。
在参数列表时表示为:
int (*func)(void *, void *)

调用：
(*func)(arg1, arg2)

声明和调用的函数名的括号是不能少的

复杂的声明

例如:

int *daytab[13]
	daytab: array[13] of pointer to int
void *comp()
	comp: function returning pointer to void 

void (*comp)()
	comp: pointer to function returning void

char (*(*x())[])()
	x: function returning pointer to array[] of pointer to function returning char

语法形式：

dcl:　　　　　optional　　*'s　　direct-dcl

direct-dcl:　　name

　　　　　　　 (dcl)

　　　　　　　 direct-dcl()

　　　　　　　 direct-dcl[optional size]

*带有的是dcl**。

结构

结构是一个或多个变量的集合，这些变量可能为多个类型，为了方便处理而把这些变量组织在一个名字下。

结构可以拷贝、赋值、传递给函数，函数也可以返回结构类型。

结构的声明

示例：

struct point {
	int x;
	int y;
}

跟声明int x, y, z这样的声明类似,结构也是能这样声明的：
struct {...} x, y, z

关键字struct引入结构声明。结构声明由一对花括号内的一系列声明组成。

结构标记

struct后面的名字是可选的，称为结构标记。

结构标记用于为结构命名，在定义之后，结构标记就代表花括号内的声明，可以用它作为该声明的简写形式。

如果结构声明的后面不带变量表，则不需要为它分配内存空间，它仅仅描述了一个结构的模板或轮廓。但是，如果结构声明中带有标记，那么在以后定义结构实例时，便可以使用该标记定义。

例如：
struct point pt;
定义了一个struct point类型的变量pt。结构的初始化可以在定义的后面使用初值表进行。初值表中每个成员对应的初值必须是常量表达式。

例如:

1	struct point maxpoint = {320, 380};

引用结构的成员

结构名.成员，这种用法跟面向对象当中的一个实例或类名.成员的调用一致。

结构的合法操作

结构的合法操作只有几种：作为一个整体复制和赋值，通过&运算符取地址，访问其成员。

结构之间不能进行比较。

结构指针

声明：
struct point *pp;

上面声明的是一个指向struct point类型对象的指针。

结构指针更推荐通过->调用其成员属性，当然通过.也是可以的，例如
struct rect r, *rp = &r;
它可以有以下四种方式调用成员属性

r.pt1.x
rp->pt1.x
(r.pt1).x
(rp->pt1).x

上面4种都是等价的。

C语言中优先级最高的4个符号

“.”
“->”
“()”
[]

因此，例如以下例子：
++p->len;
该表达式实际上是对p这个结构体的成员len+1;

结构数组

结构数组的声明有两种：

1
2
3
struct key {
...
} keytab[KEYS];

stuct key {
	..
};
struct key keytab[KEYS];

上面两种声明的意义都是声明一个结构类型key，并定义了该类型的结构数组keytab，同时分配存储空间。
其赋初值方式为：

最好是

将每一行（即每个结构）的初值都括号在花括号内
{“auto”, 0}
{“break”, 0}
{“case”, 0}

结构数组的长度

其长度在编译时已经完全确定。它等于数组项的长度乘以项数。
keytab的长度/struct key的长度

sizeof

sizeof可以用来计算任意一对象的长度。
表达式：
sizeof 对象
or
sizeof(类型名)

该函数返回一个整数值，它等于指定对象或类型占用的存储空间字节数。（严格地说，sizeof的返回值是无符号整数值，其类型为size_t,该类型在头文件<stddef.h>中定义。）其中，对象可以是变量、数组或结构；类型可以是基本类型，也可以是派生类如结构类型或指针类型。

自引用结构

一个包含自身实例的结构是非法的。

struct tnode{
	char *word;
	int count;
	struct tnode *left;
	struct tnode *right;
}

struct t{
	...
	struct s *p;
}

struct s{
	...
	struct t *q;
}

类型定义（typedef）

typedef用来建立新的数据类型名。
例如：
typedef int Length;
以上将Length定义为与int 具有同等意义的名字。

联合(union)

联合是可以（在不同时刻）保存不同类型和长度的对象的变量，编译器负责跟踪对象的长度和对齐要求。

联合提供了一种方式，以在单块存储区中管理不同类型的数据，而不需要再程序中嵌入任何同机器有关的信息。

使用联合的目的

一个变量可以合法地保存多种数据类型中任何一种类型的对象。
不像结构那样，当赋值一次之后该联合对象将会是那个赋值类型，读取的时候也是那个最近赋值的那个类型的值。也就是说*不像结构一样能赋值多个属性，而是看类型赋值了什么类型就只有那个类型的属性，但是可以重新赋值其他的类型的值，但是读取出的那个类型的属性将是最近赋值的对象的类型的那个属性。

例如：

union u_tag{
	int ival;
	float fval;
	char *sval;
} u;

这个联合对象u，假设我先赋值int a = 5;把这个a赋值给u,则u此时只有ival这个属性，u的长度也变为了4位。

联合的语法结构

其语法基于结构

union u_tag{
	int ival;
	float fval;
	char *sval;
} u;

联合只能用第一个属性进行初始化，比如上面的u,其只能用int进行初始化。

联合对象的属性访问

与结构一样

联合名.成员
联合指针->成员

c语言的文件读写

File fopen(char name, char *mode)

该函数声明于*<stdio.h>*,第一个参数是包含目标文件名的路径，第二个参数是访问模式，读（”r”）,写（”w”）, 追加（”a”）。设计到二进制文件则在这些模式的后面加上”b”即可。

如果文件不存在时，读文件会造成错误，而写和追加则会创建文件，倘若不存在的话。倘若没有权限，读文件也会报错。

getc(File fp)与putc(int c, File fp)

getc从文件中返回下一个字符，它需要知道文件指针，以确定对哪个文件进行操作; putc是一个输出函数，该函数将字符c写入到fp指向的文件中，并返回写入的字符。

int fclose(File *fp)

执行和fopen相反的操作，它断开由fopen函数建立的文件指针和外部名之间的连接，并释放文件指针以供其他文件使用。其还有一个作用是把缓冲区中由putc函数正在收集的输出写到文件中。

char fgets(char line, int maxline, File *fp)

fgets函数从fp指向的文件中读取下一个输入行（包括换行符），并将它存放在字符数line中，它最多可读取maxline-1个字符。读取的行将以’\0’结尾保存到数组中。通常返回line，但如果遇到文件结尾或发生错误，则返回NULL。

其在标准库里的具体实现

char *fgets(char *s, int n, File *iop)
{
	register int c;
	register char *cs;

	cs = s;
	while （--n > 0 && (c = getc(iop)) != EOF）
		if ((*cs++ = c) == '\n')
			break;
	*cs = '\0';
	return (c == EOF && cs == s) ? NULL : s;
}

可以看到fgets是基于库函数gets，该函数与fgets相似，但它们是对stdin和stdout进行操作；gets函数在读取字符串时将删除结尾的换行符(‘\n’)

int fputs(char line, File *fp)

输出函数fputs将一个字符串（不需要包含换行符）写入到一个文件中

如果发生错误，返回EOF，否则返回一个非负值。

其在标准库里的具体实现

int fputs(char *s, File *iop)
{
	int c;

	while(c = *s++)
		putc(c, iop);
	return ferror(iop) ? EOF : 非负值;
}

<string.h>库函数

strcat(s, t)

将t指向的字符串连接到s指向的字符串的末尾

strncat(s, t, n)

将t指向的字符串中前n个字符连接到s指向的字符串的末尾

strcmp(s, t)

根据s指向的字符串小于、等于、大于t指向的字符串的不同情况，分部返回负整数、0或正整数

大部分场景用来对比两个字符串是否等价

stcncmp(s, t, n)

同strcmp相同，但只在前n个字符中比较

strcpy(s, t)

将t指向的字符串复制到s指向的位置

strncpy(s, t, n)

将t指向的字符串中前n个字符复制到s指向的位置

strlen(s)

返回s指向的字符串的长度

strchr(s, c)

在s指向的字符串中查找c,若找到，则返回指向它第一次出现的位置的指针，否则返回NULL

strrchr(s, c)

在s指向的字符串中查找c，若找到，则返回指向它最后一次出现的位置的指针，否则返回NULL

存储管理函数

函数malloc和calloc用于动态地分配存储块。

void *malloc(size_t n)

当分成成功时，它返回一个指针，该指针指向n字节长度的未初始化的存储空间，否则返回NULL。

void *calloc(size_t n, size_t size)

当分配成功时，它返回一个指针，该指针指向的空闲空间足以容纳由n个指定长度的对象组成的数组，否则返回NULL。该存储空间被初始化为0.

free(p)

释放一个由malloc或calloc函数得到的指针所指向的存储空间。

随机数发生器函数

rand()

生成介于0和RAND_MAX之间的伪随机整数序列。RAND_MAX是在头文件<stdlib.h>中定义的符合常量。

生成一种大于等于0，但小于1的随机浮点数的方法
#define frand() ((double) rand() / (RAND_MAX+1.0))

read和write低级I/O函数

输入与输出是通过read和write系统调用实现的。在C语言程序中，可以通过函数read和write访问这两个系统调用。

在使用这两个函数之前，记得#include <unistd.h>

read(int fd, char *buf, int n)

第一参数是文件描述符，第二个参数是程序中存放读或写的数据的字符数组，第三个参数是要传输的字节数。

write(int fd, char *buf, int n)

第一参数是文件描述符，第二个参数是程序中存放读或写的数据的字符数组，第三个参数是要传输的字节数。

以上两个函数返回实际传输的字节数。

在读文件时，函数的返回值可能会小于请求的字节数。如果返回值为0，则表示已到达文件的结尾;如果返回值为-1，则表示发生了某种错误。如果是在写文件时，返回值是实际写入的字节数。如果返回值和请求写入的字节数不相等，则说明发生了错误。

open、creat、close和unlink

open与fopen相似，不同的是，前者返回一个文件描述符，它仅仅只是一个int类型的数值，而后者返回一个文件指针，如果发生错误，open将返回-1

这三个函数使用前记得#include <fcntl.h>

int open(char *name, int flags, int perms)

第一个参数，包含文件名的字符串
第二个参数，是一个int类型，用它来说明以何种方式打开文件
其主要值有：

O_RDONLY 以只读方式打开文件
O_WRONLY 以只写方式打开文件
O_RDWR 以读写方式打开文件
O_APPEND 将写入追加到文件的尾端
O_CREAT 若文件不存在，则创建它。使用该选项时，需要第三个参数mode，用来指定新文件的访问权限位

第三个参数perms用于给定权限,一般设置0即可，倘若设置了O_CREAT时，该参数需要设置创建文件之后该文件的访问权限，例如0755,当前文件的所有者可对其进行读写和执行操作，而所有者组和其他成员只能进行读和执行操作。

倘若打开一个不存在的文件，则将导致错误。可以使用creat系统调用创建新文件或覆盖已有旧文件

int creat(char *name, int perms)

如果成功创建文件，他将返回一个文件描述符，否则返回-1。如果此文件已存在，creat将把该文件的长度截断为0，从而丢弃原先已有的内容。perms用于指定的权限创建文件。

long lseek(int fd, long offset, int origin)

将文件描述符为fd的文件设置为offset，其中offset是相对orgin指定的位置而言的。随后进行读写的操作从此位置开始。origin的值可以为0、1、2,分别用于指定offset从文件开始、从当前位置或从文件结束处开始算起。

与此函数功能一样的是fseek只不过其第一个参数变为File *fd,且报错时返回一个非0值。

展开全文 >>

JNI开发入门

2020-07-14

JNI开发入门

NDK开发入门

JNI&NDK联系和区别
JNI是什么：
1. JNI是Java调用C++的规范，该规范为Java本身自带的，非Android创建。Java的JNI标准跟Android的存在不同，Android的JNI是谷歌的团队重写的，Android的更简单。
2. JNI全称Java Native Interface，即Java本地接口，JNI是Java调用Native语言的一种特性.
3. JNI使得Java与C/C++机型交互，即C++可以调Java,Java也可以调C++。
4. JNI基于JVM，因此，可以将我们编写的JNI代码运行在任何实现JNI规范的JVM上。
5. JNI代码被编写为汇编或C/C++，组装成动态库，这也是允许非静态绑定用法的前提。

NDK是什么

NDK全称Native Develop Kit，以下引用官方的话：

Android NDK是一套允许您使用原生代码语言（例如C和C++）实现部分应用的工具集。在开发某些类型应用时，这有助于您重复使用以这些语言编写的代码块。

我们可以简单的理解为NDK就是一套工具集。帮助我们实现使用C/C++来实现某些应用的功能。

为什么需要JNI

调用一些优秀的C/C++的库
JNI设计之初就保证了二进制的兼容性，C/C++直接运行在CPU上，不走JVM，所以效率比较高
保证性能

为什么需要NDK

在平台间移植应用
重复使用现有库
提升计算密集型情况下的性能
使用第三方库
不依赖Dalvik虚拟机
代码保护，C/C++反编译难度大。

C++对方法名重载——name mangling

    名字修饰，又译作名字粉碎、名字重整，译自英文name mangling或name decoration，是现代计算机程序设计语言的编译器用于解决由于程序实体的名字必须唯一而导致的问题的一种技术。
    它提供了在函数、结构体、类或其它的数据类型的名字中编码附加信息一种方法，用于从编译器中向链接器传递更多语义信息。
    该需求产生于程序设计语言允许不同的条目使用相同的标识符，包括它们占据不同的名字空间（典型的名字空间是由一个模块、一个类或显式的namespace指示来定义的）或者有不同的签名（例如函数重载）。
    任何由编译器产生的目标代码通常与另一部分的目标代码（产生于同一款或不同款的编译器）通过链接器把它们链接起来。链接器需要一大堆每个程序实体信息。例如正确链接一个函数需要它的名字、参数个数和它们的类型，等等。

如何解决name mangling

这里我们直接引用肉丝姐的星球里的内容

反射

这里的反射跟Java的反射是一样的。在运行状态下，对于任意类都可以知道它的属性和方法。

NDK开发

展开全文 >>

加固加壳技术路线与基本原理

2020-07-14

加固加壳技术路线与基本原理

第一代壳(Dex加密):

Dex字符串加密
资源加密
对抗反编译
反调试
自定义DexClassLoader

第二代壳(Dex抽取与So加固):

对抗第一代壳常见的脱壳法
1. Dex Method代码抽取到外部（通常企业版）
2. Dex动态加载
3. So加密

第三代壳（Dex动态解密与So混淆）：

Dex Method代码动态解密
SO代码膨胀混淆
对抗之前出现的所有脱壳法
启动时才加载dex,关闭app会重新加固

第四代壳（arm vmp):

展开全文 >>

彻底搞定打印不出

2020-07-13

彻底搞定打印不出

如何打印中文数组

function SimpleArray(){
	Java.perform(function(){
	Java.use('java.lang.Charater').toString().overload('char').implementation = function(char){
		var result = this.toString(char)
		console.log('char.result',char, result);
		return result;
	}

	Java.use('java.util.Arrays').toString.overload('[C']).implementation = function(charArray){
		var result = this.toString(charArray);
		console.log('charArray,result', charArray, result);
		return result;
	}
})
}

setImmediate(SimpleArray);

以上的那种还可以通过gson转换对象为json，参考前面的导入肉丝姐的gson，然后直接使用就行了。括号里面的诸如”[C”这种类型是JNI的类型，这里直接附上我搜到的图，这样大家就不用特地在百度搜了。

对照这个图看看，大写C是char类型，加上“[”这个符号的意思就是char类型数组。

如何在frida中构建array

使用Java.array('要构建的类型', [数组的value])，以下来自官网的截图

如何强制转换类的类型

如何在接口当中注册一个类

官网示例代码：

var SomeBaseClass = Java.use('com.example.SomeBaseClass');
var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');

var MyTrustManager = Java.registerClass({
  name: 'com.example.MyTrustManager',
  implements: [X509TrustManager],
  methods: {
    checkClientTrusted: function (chain, authType) {
    },
    checkServerTrusted: function (chain, authType) {
    },
    getAcceptedIssuers: function () {
      return [];
    },
  }
});

var MyWeirdTrustManager = Java.registerClass({
  name: 'com.example.MyWeirdTrustManager',
  superClass: SomeBaseClass,
  implements: [X509TrustManager],
  fields: {
    description: 'java.lang.String',
    limit: 'int',
  },
  methods: {
    $init: function () {
      console.log('Constructor called');
    },
    checkClientTrusted: function (chain, authType) {
      console.log('checkClientTrusted');
    },
    checkServerTrusted: [{
      returnType: 'void',
      argumentTypes: ['[Ljava.security.cert.X509Certificate;', 'java.lang.String'],
      implementation: function (chain, authType) {
        console.log('checkServerTrusted A');
      }
    }, {
      returnType: 'java.util.List',
      argumentTypes: ['[Ljava.security.cert.X509Certificate;', 'java.lang.String', 'java.lang.String'],
      implementation: function (chain, authType, host) {
        console.log('checkServerTrusted B');
        return null;
      }
    }],
    getAcceptedIssuers: function () {
      console.log('getAcceptedIssuers');
      return [];
    },
  }
});

肉丝姐的案例:

肉丝姐这边说：成员内部类和匿名内部类，这一块要么看smail,要么枚举所有的类，这里再给出如何枚举所有的类

Java.enumerateLoadedClasses({
	"onMatch": function(className){
		if (className.indexOf(当前app包名) < 0){
			return;
		}
		var hookCls = Java.use(className);
		var interFaces = hookCls.class.getInterfaces();
		if (interFaces.length > 0) {
			console.log(className);
			for (var i in interFaces) {
				console.log("\t", interFaces[i].toString());
			}
		}
	}
})

如何打印map

我本人之前是做java的嘛，map的迭代是有多种的，我们这里采用Iterator来进行打印会比较安全

function get_map(arg1){
	var result = "";
	var keyset = arg1.keyset();
	var it = keyset.iterator();
	while(it.hasNext()) {
		var keystr = it.next().toString();
		var valuestr = arg1.get(keystr).toString();
		var map = keystr+':'+'||';
		result += map;
	}
	send(result);
}

还有一种取巧的方法就是直接通过hook内存当中的map实例，然后调用它的toString()即可

通过indexOf可以指定获取某个map实例

展开全文 >>

代理池的设计

2020-07-13

为什么要整代理池

我们购买代理的时候不是可以直接配置好代理就可以直接用了吗？为什么还要去设计代理池。

为了更高的并发
因为代理商提供的接口往往并发量并不是很高，假如我们需要更高的并发，那一般情况下就是需要维护一个代理池。
为了保证代理的有效性
有时候代理质量参差不齐，如果业务上需要保证代理的高可用，有一个设计良好的代理池将会保证请求的质量。

设计代理池

模块分为4个：

获取模块
通过代理商提供的接口或者免费代理页面上的获取ip，抓取完成之后交由存储模块进行存储。
存储模块
存储模块用于存储我们抓下来的代理，这里要注意去重，而且还要给个标记位用来标记代理可用情况。还有个重要点那就是要保证好速度，做到实时处理，既然追求速度，直接上redis,而且为了保证好我们获取到的代理的质量一定是高的，我们可以采取打分制度，质量越高，分数越高排名也就越靠前，那我们直接使用Redis的Sorted Set就可以达到去重和自动排序的效果。
检测模块

检测模块，顾名思义用来做检测ip可用性的，需要爬哪个就检测哪个网站，这样针对性高，可用性也更可靠。如果是要做通用代理，最简单直接的直接请求百度。刚才我们也说了要给ip打分，当我们检测的次数越少，分数也就越高，当我们设置的初试分数被减为0时，移除ip。
接口模块

接口模块是用于提供服务的，一般代理池开启一个接口供爬虫程序进行访问然后获取代理，然后更换代理。也就是说代理是一个程序，爬虫是一个程序，是分开的。

展开全文 >>

B站app弹幕获取

2020-07-12

抓包

我们采用Charles抓包，首先请看这个效果
评论信息：

弹幕信息：

我们看到弹幕信息的包有很多乱码，其实这不是乱码，是被压缩了。判断依据是其accept-encoding的第一个值为gzip,请求为这个的话返回的就是图上Charles显示的这样。

对比抓到的包，首先，我们重复抓一个视频看看有什么值是固定不变的

当我们抓相同的包时，会变化的只有ts(时间戳)、sign签名。

对比其他的包

对比之后发现会变化的有oid、ts、sign；所以我们确定要抓弹幕最重要的就是构造oid、ts(10位时间戳)、sign

可以写死的参数信息有:

{
	aid: 668556934,
	appkey: 1d8b6e7d45233436,
	build: 5310300,
	mobi_app: android,
	plat: 2,
	platform: android,
	ps: 0,
	type: 1
}

我们通过参数信息先进行搜索看看

这边的搜索技巧就是搜固定的不变的值，具体原因我总结为自己的经验。

搜到如上图的地方，判断这个肯定是有调用过的函数。

目前已经有了个线索1：
pek这个类是有调用的。一般来说调用这个类肯定是为了组建一个map

展开全文 >>

彻底搞定找不到

2020-07-12

肉丝授课进阶知识点

Andriod Backup：手机磁盘的备份文件

当手机无法打开apk时，使用模拟器可以解决java层的hook，但是so层的hool是解决不了的。

objection常用操作操作：

启动objection(-d的意思是走调试模式，这个模式有attach,-g用于指定当前进程的包名)：
- objection -d -g 包名 explore
查看它的activities
- andriod hooking list activities
查看它的class
- andriod hooking list classes
通过search命令来查看某个类
- andriod hooking search classes 类名
通过watch命令来Hook某个类的所有函数(这些dump-xx都可以不要，但是加上的话可以加)
- andriod hooking list watch 包名.类名 –dump-args –dump-backtrace –dump-return

把frida-server开到公网：

使用nps(一款轻量级、高性能的内网穿透代理服务器支持几乎所有流量，如tcp\http\socks5流量转发)

客户端配置流程：

在安卓上先安装termux，这是一款在android上运行的linux终端。
下载nps的linux_arm32|64_client.tar.gz并push到手机的/sdcard/处.
通过termux解压刚才下的client，解压出三个文件，给npc赋权，然后运行。
接下来需要依赖linux_server来运行处一个web服务，启动之后，输入url进入相应页面那里有添加客户端，点击，正常配置就行，除了备注外其他可以不输入了。
弄好之后会返回之前的页，如果没有点击客户端三个字，然后跳转到相应的页，点击蓝色按钮，啥都别管直接复制那一串命令，这一串命令是后续用于连接运行了frida-server的那台服务器用的。
接着点击TCP隧道，新建，客户端ID填客户端那里的，往下接着填端口之类的。
客户端运行刚才操作5的那传代码，然后此时就已经连好了，然后

展开全文 >>

彻底搞定HOOK不上

2020-07-11

如何枚举内存中所有的类，并找出interface的实现类

// Java.enumerateClassLoaders,如果下面不对换这个试试~
Java.enumerateLoadedClasses({
	"onMatch": function(className){
		if (className.indexOf(当前app包名) < 0){
			return;
		}
		var hookCls = Java.use(className);
		var interFaces = hookCls.class.getInterfaces();
		if (interFaces.length > 0) {
			console.log(className);
			for (var i in interFaces) {
				console.log("\t", interFaces[i].toString());
			}
		}
	}
})

通过获取当前包下的所有interface,然后打印所有interface，注意有没有当前interface，如果有则说明这个类就是实现类。

如何注入gson到当前内存当中使得我们方便转换对象为json

function main(){
	Java.perform(function x(){
		console.log("In Java perform function")
		var ByteString = Java.use("com.android.okhttp.okio.ByteString");
		var verify = Java.use("org.teamsik.ahe17.qualification.Verifier")

		Java.openClassFile("/data/local/tmp/r0gson.dex").load();
		const gson = Java.use("com.r0ysue.gson.Gson");

		var stringClass = Java.use("java.lang.String");

		var p = stringClass.$new("09042ec2c2c08c4cbece042681cafld13984f24a");
		var pSign = p.getBytes();
		console.log(gson.$new().toJson(p));
		console.log(ByteString.of(pSign).hex());

		var buffer = Java.array('byte', [ 13, 37, 42 ])
		console.log(gson.$new().toJson(buffer));
	})
}

r0gson是肉丝编译的gson，导入这个gson就可以转对象为json,以上仅是示例，具体操作还是随机应变。附图：

如何打印byte[]

var ByteString = Java.use("com.android.okhttp.okio.ByteString");
var j = Java.use("c.business.comm.j");
j.x.implementation = function() {
    var result = this.x();
    console.log("j.x:", ByteString.of(result).hex());
    return result;
};

j.a.overload('[B').implementation = function(bArr) {
    this.a(bArr);
    console.log("j.a:", ByteString.of(bArr).hex());
};

利用安卓自带的ByteString类

如何打印函数的堆栈信息

1
2
3

function get_stack(){
	console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()));
}

当需要Java来实现加密过程，如何把它导成dex并在js当中引入这个dex

打开AndroidStudio，实现加密过程
Sdk目录下的build-tools文件夹下的相应api版本包名内部找到d8这个文件,然后直接通过命令行转相应的class文件为dex
把生成的dex， adb push到安卓机里，并添加权限
在hook的js代码里面通过Java.openClassFile(相应的dex文件所在位置).load()加载进内存当中，这个函数会返回相应的dex可以通过变量去接这个值，也可以不接(注意，当这段js在Java.perform内部可以直接用.load,不在则不可以)
此时就可以通过Java.use(“要调用的类路径”)来调用相应的函数了

z3用于约束求解和符号执行

WallBreaker

该工具是葫芦娃大佬基于objection和frida写的一个objection插件。github:https://github.com/hluwa/Wallbreaker

如何去使用WallBreaker

先git clone WallBreaker到本地
使用命令行去启动objection
objection -g 包名 explore
objection启动之后，命令行添加这条命令plugin load WallBreaker路径

这个时候就可以使用WallBreaker了，其相应命令如下：

plugin wallbreaker classsearch <pattern>
plugin wallbreaker classdump <classname> [--fullname]
plugin wallbreaker objectsearch <classname>
plugin wallbreaker objectdump <handle> [--fullname]

plugin wallbreaker classdump 包名:

以上为wallbreaker的效果图

ZenTracer

如何安装ZenTracer

先git该项目github: https://github.com/hluwa/ZenTracer
pip install PyQt5，有时候可能下载不了，这种情况升级一下pip,pip install --upgrade pip
执行ZenTracer，python ZenTracer.py
手机启动frida,然后再打开文件，就可以通过ZenTracer来hook东西了

以上这些工具其实作用不大，最好的工具还是自己写代码hook

Frida-DEXdump

这个又是葫芦娃大佬写的工具，该工具十分牛逼，通过暴力搜索在内存中找到dex然后脱壳。

使用方法

大佬的原话是这样：

github: https://github.com/hluwa/FRIDA-DEXDump

Frida-unpack

该工具也是用来脱壳的，这个不做详细介绍，因为两者使用起来都简单，当然。当然两个都可能会出现dump不完全的情况。
github: https://github.com/dstmath/frida-unpack

展开全文 >>

python装饰器

2020-07-11

python装饰器

什么是装饰器？

装饰器是可调用的对象，其参数是另一个函数（被装饰的函数）。装饰器可能会处理被装饰的函数，然后把它返回，或者将其替换成另一个函数或可调用对象。

装饰器总是会比被装饰器先执行。

什么是一等对象？

可以把函数赋给变量
可以变成参数传递函数
函数里面可以定义函数
函数可以做为返回值返回（闭包）

装饰器代码示例

普通装饰器


def my_decorator(func):
    def wrapper():
        print('wrapper of decorator')
        func()
    return wrapper

@my_decorator
def greet():
    print('hello world')

greet()

带参数的装饰器


def my_decorator(func):
    def wrapper(message):
        print('wrapper of decorator')
        func(message)
    return wrapper


@my_decorator
def greet(message):
    print(message)


greet('hello world')

# 输出
wrapper of decorator
hello world

上面那种一般都会写成,这样写会比较灵活。


def my_decorator(func):
    def wrapper(*args, **kwargs):
        print('wrapper of decorator')
        func(*args, **kwargs)
    return wrapper

带自定义参数的装饰器


def repeat(num):
    def my_decorator(func):
        def wrapper(*args, **kwargs):
            for i in range(num):
                print('wrapper of decorator')
                func(*args, **kwargs)
        return wrapper
    return my_decorator


@repeat(4)
def greet(message):
    print(message)

greet('hello world')

# 输出：
wrapper of decorator
hello world
wrapper of decorator
hello world
wrapper of decorator
hello world
wrapper of decorator
hello world

类装饰器


class Count:
    def __init__(self, func):
        self.func = func
        self.num_calls = 0

    def __call__(self, *args, **kwargs):
        self.num_calls += 1
        print('num of calls is: {}'.format(self.num_calls))
        return self.func(*args, **kwargs)

@Count
def example():
    print("hello world")

example()

# 输出
num of calls is: 1
hello world

example()

# 输出
num of calls is: 2
hello world

类装饰器，要装饰的类必须实现__call__这个魔法函数。

装饰器的嵌套


import functools

def my_decorator1(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print('execute decorator1')
        func(*args, **kwargs)
    return wrapper


def my_decorator2(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print('execute decorator2')
        func(*args, **kwargs)
    return wrapper


@my_decorator1
@my_decorator2
def greet(message):
    print(message)


greet('hello world')

# 输出
execute decorator1
execute decorator2
hello world

异步的装饰器

import pprint
import aiohttp
import datetime
import asyncio


def time_log(func):
    async def wrap(*args, **kwargs):
        print(f'现在时间：{datetime.datetime.now()}，程序开始运行')
        result = await func(*args, **kwargs)
        print(f'现在时间：{datetime.datetime.now()}，运行结束')
        return result
    return wrap

@time_log
async def get(n):
    async with aiohttp.ClientSession() as client:
        resp = await client.get(f'http://httpbin.org/delay/{n}')
        result = await resp.json()
    pprint.pprint(result, indent=2)


asyncio.run(get(3))

当需要装饰异步函数时，装饰器也必须要为异步

展开全文 >>