SELinux机制

SELinux

SELinux是Linux的一个分支，是Linux的一个内核模块，也是Linux的一个安全子系统。

SELinux的作用

其最主要的作用最大限度地减小系统中服务进程可访问的资源

DAC（自主访问控制）

在普通的Linux系统当中，决定某个资源能被访问的因素是某个用户是否拥有要访问资源所对应的权限。而root用户不受任何管制，可以访问系统上任意资源。这种权限管理机制的主体是用户，也称为自主访问控制（DAC）

MAC（强制访问控制）

在SELinux系统中，决定一个资源除了判断某个用户是否拥有所要访问资源所对应的权限以外，还会判断某个进程是否有权限访问对应资源。

SELinux的工作模式
  1. enforcing: 强制模式。违反SELinux规则的行为将被阻止且记录到日志中。
  2. permissive: 宽容模式。违反SELinux规则的行为只会记录到日志中。一般为调试用。
  3. disabled: 关闭SELinux。

手机一般默认强制模式，当然也有的手机会默认为宽容模式。

切换SELinux的工作模式

setenforce 1|0,为1时切换强制模式，为0时切换为宽容模式。

SELinux在Android上的三种类型
  1. untrusted_app,第三方app，没有Android平台签名,没有system权限。
  2. platform_app,有Android平台签名，没有system权限。
  3. system_app,有Android平台签名和有system权限。

展开全文 >>

Svc指令获取设备信息

SVC指令

SVC（systemcall）是Linux内核的入口，当代码进入内核态时，就开始执行内核的代码，用户是无法对内核进行操作的。

内核函数，诸如open、read函数这些Linux底层的函数，最终会调用system_call函数切换到内核态，也就是SVC指令，在ARM汇编进行反编译的时候直接进入内核模式。在用户空间时，代码是不安全的，有可能被hook，而在代码通过SVC进入内核空间，代码是不能被hook的，因为进入内核的内存是无法进行读写的。所以很多读取设备信息都通过SVC指令进行读取，无法被HOOK，这种也叫做SVC穿透（可以通过ptrace函数来解决穿透问题，ptrace是Linux调试的函数，它的权限是最高的，它连内核的函数都可以拦截的）

内联汇编

在C/C++代码当中插入汇编代码就叫做内联汇编。

展开全文 >>

狗东直播sign分析

frida反调试的解决方案
  1. 在lib/armeabi-v7a/目录里grep -ril "frida"和grep -ril "frida-server"
    找到共同这两个字符串的so。
    picture 1

该so就是我们需要进行反反frida调试的so。

  1. 找到检测的点
    在IDA中通过快捷键Shift+F12打开String windos来找到字符串frida的位置。
    picture 2
    这里只是在arm反汇编当中找到字符串，可是我们看反汇编其实会比较麻烦且费时，优先选择F5来把反汇编代码转换成C伪代码。
    picture 3
    找到函数的导出名
    picture 4
    反汇编的效果如下（JNI函数的第一个参数一般是JNIEnv*类型，当然碰到JNI_Onload及更早执行的.init和.init_array除外）
    picture 5
    按Y改变变量的参数类型，按N进行变量的更名。

通过frida脚本想hook access函数
picture 6
发现在access函数输出frida字符串之前，frida就直接崩掉了，说明，检测frida的进程有比access函数更早的地方。
picture 7
来看看这个地方。
picture 8
如果熟悉端口检测的话可以看到5D8A和69A2和69A3这三个16进制数分别对应10进制数，23946、27042、27043。
这三个端口号第一个是android-server默认占用的端口，27042是frida默认占用的端口.
picture 9
端口检测这个很好解决，要么修改检测的端口号，要么修改frida的默认占用的端口
picture 10
这样设置即可。也可以头铁，通过hook这里的strstr函数，把检测的端口号进行hook修改。我们这里头铁看看吧（笑）。
picture 11
哈哈，成功了铁头！
但是还是崩。。。还输出了这段带有frida的字符串。嗯看来还有地方比对frida的字符串。
再改改strstr的第二个参数，假如包含frida字样我们就改掉他，（注意需要改变一下返回值）
picture 12
好嘞反调试就这么过了

抓包分析

picture 13
抓包发现只有这三个参数是变化的，那我们的破解参数主要为st、sv、sign

st: 盲猜时间戳
sv: 暂定
sign: 32位，神似md5

静态分析

首先搜索一下sign=
picture 14
14个结果，而且有我们刚才抓包看到的其他参数，看来我们要找的地方就在这附近。

Objection hook com.jingdong.jdsdk.network.toolbox.HttpSetting.getMd5这个函数看看有没有经过这个。
picture 16
有经过
picture 17
然后可以看到实际上sign是在这函数经过之前就已经生成了。
picture 18
看看调用栈。经静态分析，这些之前都是些调用发送包的函数。
那只有一种可能sign的生成函数在getMd5这个函数内部当中被调用。那么极有可能是getUrl()里面。
picture 19
既然有getUrl,那肯定有setUrl我们通过Objection来hook看看能不能看到有价值的信息。
picture 20
跟随调用栈来到这里
picture 21
跟进去
picture 22

好家伙又接着hook setSignature看看调用栈。
picture 23
可以看到参数传进来时已经有sign和其他两个我们需要的参数，那跟随调用栈往上跟。
picture 24
掉进signature里发现
picture 25
发现这是一个接口类。通过frida脚本找到其实现类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Java.enumerateLoadedClasses({
    onMatch: function(className){
        if (className.indexOf(包名) < 0){
            return;
        }
        var hookCls = Java.use(className);
        // getInterfaces()可以把当前加载的类，类所实现的interface全都打印出来。
        var interFaces = hookCls.class.getInterfaces();
        if (interFaces.length > 0){
            console.log(className);
            for (var i in interFaces){
                console.log('\t', interFaces[i].toString())
            }
        }
    }
})

服了没找到。在看看刚才的地方
picture 26
picture 27
一路追，看到这个。。。看来也不是他，佛了，换换别的反编译器GDA看看。
picture 28

这种情况下可以试试看在so当中碰碰运气。
picture 29

picture 31

picture 30

看来我们应该找到了。。。

picture 32
HOOK看看通过不。
picture 33
有经过，且结果跟我们刚才分析的相同，所以这里就是我们想要找到的sign的位置。
com.jingdong.common.utils.BitmapkitUtils.getSignFromJni

展开全文 >>

通用抓包hook脚本 

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
function hook(){
    Java.perform(function(){
        Java.use("java.net.SocketOutputStream").socketWrite0.overload('java.io.FileDescriptor', '[B', 'int', 'int').implementation = function (fd, bytearry, offset, byteCount) {
            var result = this.socketWrite0(fd, bytearry, offset, byteCount);
            // message["src_addr"] = ntohl(ipToNumber((this.socket.value.getLocalAddress().toString().split(":")[0]).split("/").pop()));
            // message["src_port"] = parseInt(this.socket.value.getLocalPort().toString());
            // message["dst_addr"] = ntohl(ipToNumber((this.socket.value.getRemoteSocketAddress().toString().split(":")[0]).split("/").pop()));
            // message["dst_port"] = parseInt(this.socket.value.getRemoteSocketAddress().toString().split(":").pop());
            printByteArray(bytearry);
            console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
            return result;
          }
          Java.use("java.net.SocketInputStream").socketRead0.overload('java.io.FileDescriptor', '[B', 'int', 'int', 'int').implementation = function (fd, bytearry, offset, byteCount, timeout) {
            var result = this.socketRead0(fd, bytearry, offset, byteCount, timeout);
            // message["src_addr"] = ntohl(ipToNumber((this.socket.value.getRemoteSocketAddress().toString().split(":")[0]).split("/").pop()));
            // message["src_port"] = parseInt(this.socket.value.getRemoteSocketAddress().toString().split(":").pop());
            // message["dst_addr"] = ntohl(ipToNumber((this.socket.value.getLocalAddress().toString().split(":")[0]).split("/").pop()));
            // message["dst_port"] = parseInt(this.socket.value.getLocalPort());
            printByteArray(bytearry);
            console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
            return result;
          }
          Java.use("com.android.org.conscrypt.ConscryptFileDescriptorSocket$SSLOutputStream").write.overload('[B', 'int', 'int').implementation = function (bytearry, int1, int2) {
            var result = this.write(bytearry, int1, int2);
            printByteArray(bytearry);
            console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
    
            return result;
          }
          Java.use("com.android.org.conscrypt.ConscryptFileDescriptorSocket$SSLInputStream").read.overload('[B', 'int', 'int').implementation = function (bytearry, int1, int2) {
            var result = this.read(bytearry, int1, int2);
            printByteArray(bytearry);
            console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
            return result;
          }
          var LinuxClass = Java.use('libcore.io.Linux');
          //private native int recvfromBytes(FileDescriptor fd, Object buffer, int byteOffset, int byteCount, int flags, InetSocketAddress srcAddress) throws ErrnoException, SocketException;
          LinuxClass.recvfromBytes.implementation = function (arg0, arg1, arg2, arg3, arg4, arg5) {
              var size = this.recvfromBytes(arg0, arg1, arg2, arg3, arg4, arg5);
              var bytearray = Java.array('byte', arg1);
              var content = "";
              printByteArray(bytearray);
              console.log("address:" + arg5 + " [" + Process.getCurrentThreadId() + "]recvfromBytes:size:" + size + ",content:" + JSON.stringify(arg1) + "---content," + content);
              console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
              return size;
          }
          //private native int sendtoBytes(FileDescriptor fd, Object buffer, int byteOffset, int byteCount, int flags, InetAddress inetAddress, int port) throws ErrnoException, SocketException;
          // private native int sendtoBytes(FileDescriptor fd, Object buffer, int byteOffset, int byteCount, int flags, SocketAddress address) throws ErrnoException, SocketException;
          LinuxClass.sendtoBytes.overload('java.io.FileDescriptor', 'java.lang.Object', 'int', 'int', 'int', 'java.net.InetAddress', 'int').implementation = function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
              var size = this.sendtoBytes(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
              var bytearray = Java.array('byte', arg1);
              var content = "";
              printByteArray(bytearray);
              console.log("address:" + arg5 + ",port" + arg6 + " [" + Process.getCurrentThreadId() + "]LinuxClass11.sendtoBytes:len:" + size + "--content:" + JSON.stringify(arg1) + "--content:" + content);
              console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
              return size;
          }
          LinuxClass.sendtoBytes.overload('java.io.FileDescriptor', 'java.lang.Object', 'int', 'int', 'int', 'java.net.SocketAddress').implementation = function (arg0, arg1, arg2, arg3, arg4, arg5) {
              var size = this.sendtoBytes(arg0, arg1, arg2, arg3, arg4, arg5);
              var bytearray = Java.array('byte', arg1);
              var content = "";
              printByteArray(bytearray);
              console.log("address:" + arg5 + " [" + Process.getCurrentThreadId() + "]LinuxClass22.sendtoBytes:len:" + size + "--content:" + JSON.stringify(arg1) + ",content:" + content);
              console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
              return size;
          }
  
    });
}

function printByteArray(byteArray){
    var content = '';
    for(var i = 0;i < byteArray.length; i++){
        if(byteArray[i] > 32 && byteArray[i] < 126){
            content += String.fromCharCode(byteArray[i])
        }
    }
    console.log(content);
}

function main(){
    hook();
}

setImmediate(main);

展开全文 >>

Java层的Socket及SSL的hook点分析

编写示例代码

通过自己编译且运行Socket示例的客户端（手机）与服务端代码，通过hook的方式来快速分析Socket发送流程。
客户端代码：

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
import android.util.Log;

import org.json.JSONException;
import org.json.JSONObject;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Date;

public class MySocket {
    private String serverIp = "192.168.3.23";
    private int serverPort = 9999;
    private Socket serverSocket = null;
    private OutputStream outputstream = null;
    private InputStream inputStream = null;
    private long lastheartresponse = 0;
    public  boolean connected = false;

    public void sendMessage(String msg){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                if (connected == false) {
                    Log.i("dta => ", "watting connect......");
                } else {
                    try {
                        if (outputstream != null) {
                            String crypt = msg;
                            outputstream.write(crypt.getBytes("utf-8"));
                            outputstream.flush();
                        }

                    } catch (IOException e) {
                        close();
                        e.printStackTrace();
                    }
                }
            }
        });
        thread.start();
    }

    public void close() {
        try {
            if (serverSocket != null) {
                serverSocket.close();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
        inputStream = null;
        outputstream = null;
        connected = false;
    }

    public void heart(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    Date date = new Date();
                    String timestamp = String.valueOf(date.getTime());
                    long currenttime = Long.valueOf(timestamp);;
                    if (lastheartresponse != 0) {
                        long offset = currenttime - lastheartresponse;
                        int seconds = (int) (offset / 1000);
                        if (seconds > 10) {
                            close();
                        }
                    }
                    try {
                        Thread.currentThread().sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        });
        thread.start();
    }

    public void receiveMessage(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                int arraysize = 1024;
                byte[] content = new byte[arraysize];
                while (true) {
                    if (inputStream != null) {
                        try {
                            int count = inputStream.read(content);
                            if (count > 0 && count < arraysize) {
                                byte[] tmparray = new byte[count];
                                System.arraycopy(content, 0, tmparray, 0, count);
                                String str = new String(tmparray, "utf-8");
                                Log.i("dta => ", str);
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                            close();
                            break;
                        }
                    } else {
                        close();
                        break;
                    }
                }
            }
        });
        thread.start();
    }

    public void service(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    if (connected == false) {
                        try {
                            serverSocket = new Socket(serverIp, serverPort);
                            serverSocket.setSoTimeout(10*1000);
                            connected = true;
                            outputstream = serverSocket.getOutputStream();
                            inputStream = serverSocket.getInputStream();
                            receiveMessage();
                        } catch (IOException e) {
                            e.printStackTrace();
                            connected = false;
                            serverSocket = null;
                            outputstream = null;
                            inputStream = null;
                        }
                    }
                    if (outputstream != null) {
                        try {
                            JSONObject object = new JSONObject();
                            object.put("dta", "hello server");
                            sendMessage(object.toString());
                        } catch (JSONException e) {
                            e.printStackTrace();
                        }
                    }
                    try {
                        Thread.currentThread().sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        });
        thread.start();
    }
}

服务端代码：

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
# coding=utf-8
import json
import threading
import socket

socket_list = []

s = socket.socket()
s.bind(('0.0.0.0', 9999))
s.listen()


def read_from_client(s):
    try:
        return s.recv(1024).decode('utf-8')
    except:
        socket_list.remove(s)


def server_target(s):
    try:
        while True:
            content = read_from_client(s)
            if content is None:
                break
            length = len(content)
            if length > 0:
                print("receive:" + content)
                send_message = {"dta": "hello client"}
                print("send:" + str(send_message))
                s.send(json.dumps(send_message).encode('utf-8'))
    except IOError as e:
        print(e.strerror)


while True:
    c, addr = s.accept()
    socket_list.append(c)
    threading.Thread(target=server_target, args=(c,)).start()

通过objection获取所有socket类

先通过objection的android hooking search 来查找相应的Socket类,并复制这些类到一个txt文件当中然后通过Alt+Shift+鼠标拖拽光标的方式给所有类加上一句android hooking watch class
picture 3

picture 2

通过objection -g 包名 explore -c 文件名.txt来在启动objection的时候批量hook这些类，当然这过程当中很可能经常会崩，把崩的那句一条条的删掉。
picture 1

来到这里
picture 4
虽然objection崩了，但是还是hook到了关键类的信息

1
2
3
4
Called java.net.SocketOutputStream.write([B)
Called java.net.SocketOutputStream.socketWrite([B, int, int)
Called java.net.AbstractPlainSocketImpl.acquireFD()
Called java.net.SocketOutputStream.socketWrite0(java.io.FileDescriptor, [B, int, int)                                           Called java.net.AbstractPlainSocketImpl.releaseFD()

java.net.AbstractPlainSocketImpl看到这个是一个抽象类就不用管这个类了。直接看SocketOutputStream
picture 5

SocketOutputStream,通过Wallbreaker在内存当中搜索一下这个类的其中一个实例看看有没有我们需要的东西。
picture 6
该实例的域里存在着两个对象，通过这两个对象可以拿到目标的ip（addr）、目标的port（port）、本地的发送端口（localPort）
那我们再看看java.net.SocketOutputStream的函数的一些信息。
picture 8
picture 9

picture 10
可以看到所有的函数最后都会经过private native void socketWrite0(FileDescriptor fd, byte[] b, int off, int len) throws IOException;
我们通过frida来打印一下它的参数是什么。
picture 11
此处可以看到byte[]数组就是我们发送的数据~

此处附上打印byte数组的方法：

1
2
3
4
5
6
7
8
9
function printByteArray(byteArray){
    var content = '';
    for(var i = 0;i < byteArray.length; i++){
        if(byteArray[i] > 32 && byteArray[i] < 126){
            content += String.fromCharCode(byteArray[i])
        }
    }
    console.log(content);
}

因为其是一个native函数，说明该函数是Java层与JNI层的一个“桥梁”，也就是Java的Socket最终发送到JNI的那么一个点。可以通杀Java层。

把刚才的那些hook点在文本当中去掉再用objection hook一遍，以便我们拿到服务端返回的信息的Hook点。
picture 12
直接看源码。
picture 13
看了源码之后发现，其最终走的是private native int socketRead0(FileDescriptor fd, byte b[], int off, int len, int timeout)

通过对比socketWrite0和SocketOutputStream的名称发现，这两个类可以说是成对出现的，即写——读成对。

以上是SocketOutputStream和SocketInputStream两个hook点socketWrite0和socketRead0的分析流程。

hook ssl握手之前的点

按照上面的做法进行android hooking search ssl,找到所有关于ssl的类，并把垃圾类都删掉之后进行objection的trace。时间关系这边直接给出那个待trace的类的log

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
android hooking watch class android.net.SSLCertificateSocketFactory
android hooking watch class android.net.SSLCertificateSocketFactory$1
android hooking watch class android.net.SSLSessionCache
android hooking watch class android.net.ssl.SSLSockets
android hooking watch class com.android.org.conscrypt.ConscryptFileDescriptorSocket$SSLInputStream
android hooking watch class com.android.org.conscrypt.ConscryptFileDescriptorSocket$SSLOutputStream
android hooking watch class com.android.org.conscrypt.DefaultSSLContextImpl
android hooking watch class com.android.org.conscrypt.NativeCrypto$SSLHandshakeCallbacks
android hooking watch class com.android.org.conscrypt.NativeRef$SSL_SESSION
android hooking watch class com.android.org.conscrypt.NativeSsl
android hooking watch class com.android.org.conscrypt.NativeSsl$1
android hooking watch class com.android.org.conscrypt.NativeSsl$BioWrapper
android hooking watch class com.android.org.conscrypt.NativeSslSession
android hooking watch class com.android.org.conscrypt.NativeSslSession$1
android hooking watch class com.android.org.conscrypt.NativeSslSession$Impl
android hooking watch class com.android.org.conscrypt.NativeSslSession$Impl$1
android hooking watch class com.android.org.conscrypt.OpenSSLBIOInputStream
android hooking watch class com.android.org.conscrypt.OpenSSLContextImpl
android hooking watch class com.android.org.conscrypt.OpenSSLProvider
android hooking watch class com.android.org.conscrypt.OpenSSLServerSocketFactoryImpl
android hooking watch class com.android.org.conscrypt.OpenSSLSignature
android hooking watch class com.android.org.conscrypt.OpenSSLSignature$1
android hooking watch class com.android.org.conscrypt.OpenSSLSignature$EngineType
android hooking watch class com.android.org.conscrypt.OpenSSLSocketFactoryImpl
android hooking watch class com.android.org.conscrypt.OpenSSLSocketImpl
android hooking watch class com.android.org.conscrypt.OpenSSLX509CRL
android hooking watch class com.android.org.conscrypt.OpenSSLX509CertPath
android hooking watch class com.android.org.conscrypt.OpenSSLX509CertPath$1
android hooking watch class com.android.org.conscrypt.OpenSSLX509CertPath$Encoding
android hooking watch class com.android.org.conscrypt.OpenSSLX509Certificate
android hooking watch class com.android.org.conscrypt.OpenSSLX509CertificateFactory
android hooking watch class com.android.org.conscrypt.OpenSSLX509CertificateFactory$1
android hooking watch class com.android.org.conscrypt.OpenSSLX509CertificateFactory$2
android hooking watch class com.android.org.conscrypt.OpenSSLX509CertificateFactory$Parser
android hooking watch class com.android.org.conscrypt.OpenSSLX509CertificateFactory$ParsingException
android hooking watch class com.android.org.conscrypt.SSLClientSessionCache
android hooking watch class com.android.org.conscrypt.SSLParametersImpl
android hooking watch class com.android.org.conscrypt.SSLServerSessionCache
android hooking watch class com.android.org.conscrypt.SSLUtils
android hooking watch class com.android.org.conscrypt.SSLUtils$SessionType
android hooking watch class javax.net.ssl.ExtendedSSLSession
android hooking watch class javax.net.ssl.HandshakeCompletedEvent
android hooking watch class javax.net.ssl.HandshakeCompletedListener
android hooking watch class javax.net.ssl.SSLContext
android hooking watch class javax.net.ssl.SSLContextSpi
android hooking watch class javax.net.ssl.SSLHandshakeException
android hooking watch class javax.net.ssl.SSLParameters
android hooking watch class javax.net.ssl.SSLPeerUnverifiedException
android hooking watch class javax.net.ssl.SSLProtocolException
android hooking watch class javax.net.ssl.SSLServerSocketFactory
android hooking watch class javax.net.ssl.SSLSession
android hooking watch class javax.net.ssl.SSLSessionBindingEvent
android hooking watch class javax.net.ssl.SSLSessionBindingListener
android hooking watch class javax.net.ssl.SSLSessionContext

然后找到带有read或者write方法的类，只有这些类才是我们想要的类。

注意，可能也不会走这个ssl类，在OpenSSLSocketFactoryImpl.java有另一个ssl分支
picture 1

而在android8.1以下没有这种情况，这是由于8.1以上这部分开始换成工厂模式重新编写了一下，android8.1以下ssl hook这个点OpenSSLSocketImpl即可。

展开全文 >>

ndk开发

NDK

NDK开发优点
  1. NDK是一系列工具的集合
  2. NDK提供了一份稳定、功能有限的API库
  3. C/C++甚至汇编的代码可以通过NDK的工具链最终编译生成动态库，最后通过JNI完成和Dalvik/ART虚拟机环境中的Java代码的交互。

使用NDK开发的so不再具有跨平台特性，需要编译提供不同平台支持ABI：ApplicationBinary Interface。

NDK开发缺点
  1. 开发效率低
  2. 开发难度大
  3. 稳定性难以保证
编写第一个含ndk开发的app

  1. new Project选择Native C++
    picture 1

  2. Next
    picture 2

  3. Next
    picture 3
    Finsh。

picture 4
可以看到项目的默认全貌是这样的。

cpp包下就是我们要编写的JNI代码存放的地方，native-lib.cpp是默认生成的cpp文件，先挨个解释一下

JNIEXPORT

picture 5

JNIEXPORT是一个宏定义，其作用为告知编译器保留其函数名称，即保留导出函数名。只要设置这个之后我们可以通过IDA可以直接的搜索到其函数名。
picture 6

extern “C”

告诉编译器该函数按照C函数的形式进行编译，为什么强调是按照C函数的形式进行编译？因为C++函数名会进行name mangling操作，该函数名被编译的时候会跟我们编写的时候不一样，以下给出一个简单的示例
c++:
picture 10

c:
picture 9

android studio帮我们生成的函数是一个静态注册的函数，静态注册的函数有几个特征。
其函数名为Java_包名_类名_函数名为函数的名称,并且在相应的Java类当中还能找到其加载的相应so与静态注册的函数。
picture 7

static native

和非静态函数不同的是，由于静态函数可以直接通过类名进行直接的调用，所以和非静态函数相比其第二个参数不再是this,也就是jobject,而应该是jclass
picture 1

picture 4

对于一个JNI函数来说，其参数肯定是不少于两个的，从第三个开始才是JNI函数自己的参数。

JNIEnv*

Java Native Interface Environment,JNI接口指针，指向本地方法的一个函数表，该函数表中的每一个成员指向了一个JNI函数
picture 4

JNIEnv表示Java调用native语言的环境，是一个封装了大量JNI方法的指针。
JNIEnv只在创建它的线程生效，如需要访问JNI，必须调用AttachCurrentThread关联，并使用DetachCurrentThread解除链接

引入C头文件

引入一个C写的头文件是有讲究的，前面有提到函数要编译成C函数需要添加extern “C”，而引入C的.h（即头文件）有要注意的点么？有！
以下给出一个示例

1
2
3
extern "C"{
  #include "add.h"
}
日志的打印
  1. 先引入#include <android/log.h>
  2. 找到int __android_log_print(int prio, const char* tag, const char* fmt, ...)该函数用于直接的日志打印

第一个参数: 按需从以下参数当中选择（包含在<android/log.h>当中）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/** For internal use only.  */
ANDROID_LOG_UNKNOWN = 0,
/** The default priority, for internal use only.  */
ANDROID_LOG_DEFAULT, /* only for SetMinPriority() */
/** Verbose logging. Should typically be disabled for a release apk. */
ANDROID_LOG_VERBOSE,
/** Debug logging. Should typically be disabled for a release apk. */
ANDROID_LOG_DEBUG,
/** Informational logging. Should typically be disabled for a release apk. */
ANDROID_LOG_INFO,
/** Warning logging. For use with recoverable failures. */
ANDROID_LOG_WARN,
/** Error logging. For use with unrecoverable failures. */
ANDROID_LOG_ERROR,
/** Fatal logging. For use when aborting. */
ANDROID_LOG_FATAL,
/** For internal use only.  */
ANDROID_LOG_SILENT, /* only for SetMinPriority(); must be last */

第二个参数: tag

第三个参数则为要输出的内容

编写一个含引入C头文件的程序并调用

以下结合以上的知识点给出示例截图
picture 6
tips:
添加一个源码文件需要让其在CMakeLists.txt当中的add_library里添加具体的源码文件名.后缀
picture 7

picture 8

JNI的基本数据类型

picture 10

一个小demo
picture 11
picture 12
picture 13

JNI引用数据类型

picture 2

JNI引用数据类型的继承关系

picture 3

JNI常用的字符串操作
jstring NewStringUTF(const char* bytes)

函数使用给定的C字符串创建一个新的JNI字符串（jstring），不能为构造的java.lang.String分配足够的内存，则会抛出OutOfMemoryError异常，并返回null

const char* GetStringUTFChars(jstring string,jboolean* isCopy)

函数可用于从给定的Java的jstring创建新的C字符串并且要为新诞生的UTF-8字符串分配内存，如果无法分配内存，则该函数返回NULL。该操作有可能因为内存太少失败，失败时会返回NULL并抛出OutOfMemoryError异常，在不使用该函数返回的字符串时，需要释放内存和引用以便对其进行垃圾回收，因此需要始终调用ReleaseStringUTFChars()

jsize GetStringUTFLength(jstring string)

用于获取jstring的长度。

常用字符串操作释义

picture 5

demo

picture 8

picture 9

JNI调用Java
JNI创建Java对象

有两种方法

  1. NewObject
    示例
    1
    2
    3
    4
    5
    6
    jclass jclazz = env->FindClass("com/example/juziss/ReflectionClass");
    jmethodID jmethodId = env->GetMethodID(jclazz, "<init>", "()V");
    jobject obj = env->NewObject(jclazz, jmethodId);
    if (obj != nullptr){
        __android_log_print(ANDROID_LOG_INFO, "juzissJNI", "JNI init Java class sucess");
    }

picture 1

  1. 使用AllocObject创建Java对象

    使用AllocObject可以根据传入的jclass创建一个Java对象，但是该对象的状态是非初始化的，在使用这个对象之前必须要用CallNovirtualVoidMethod来进行初始化，这样可以延迟构造函数的调用，该方式使用的很少。

1
2
3
4
5
jclass jclazz = env->FindClass("com/example/juziss/ReflectionClass");
jstring word = env->NewStringUTF("HelloReflection");
jmethodID jmethodId = env->GetMethodID(jclazz, "<init>", "(Ljava/lang/String;)V");
jobject obj = env->AllocObject(jclazz);
env->CallNonvirtualVoidMethod(obj, jclazz, jmethodId, word);

picture 1

picture 2

类描述符

将原报名+类名改成原包名的.改成/ + 类名，例如com/example/juziss/ReflectionClass

函数描述符

将参数类型的域描述符按照申明顺序放入一对括号中后跟返回值类型的域描述符例如public static void publicStaticMethod() -> ()V ;例如int func(int a, Object obj) -> (ILjava/lang/Object;)I

JNI调用Java其实符合反射调用的步骤流程

  1. 找到需要调用的类
    env-> FindClass(“xx/xx/xx”)

  2. 获取想要调用的类的属性id
    picture 1

    获取想要调用的类的方法ID
    picture 2

  3. 调用
    方法调用时env->Call开头的函数,属性调用env->GetxxField，属性调用和函数调用无需考虑Java反射当中的安全检查！

示例：
picture 3

picture 4

tips:
要想调用一个jobject对象的属性可以使用GetObjectXXX/SetObjectXXX

获取Java数组长度

env->GetArrayLength(jarray)

得到数组的指针

env->GetIntArrayElements(jarray, 0);

遍历数组中的每一个元素
1
2
3
4
for (int i = 0;i < length;i++){
  (*(arr+i)) += 5;
}

CallXXMethodA与CallXXMethodV与CallXXMethod函数的区别

CallXXMethodA:
picture 1

CallXXMethod与CallXXMethodV:
picture 2
可以看到CallXXMethod最终调用的是“V”，而“A”跟前两个的区别在于其传参的形式不一样而已。

动态注册

JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *unused)
动态注册主要依赖于JNI_Onload函数进行函数的注册，该函数被调用的时机早于静态注册的函数，其在System.loadLibary/load这两个函数执行时将被执行，所以时机早于静态注册。

  1. 定义
    通过RegisterNatives方法手动完成native方法和so中的方法的绑定，这样虚拟机就可以通过这个函数映射关系直接找到相应的方法了。
RegisterNatives函数的使用

返回值：成功则返回JNI_OK(0),失败则返回一个负值。
需要三个参数：要注册的jni函数所属的jclass, JNINativeMethod数组指针，注册的jni函数个数。
picture 1

is_fast

该变量的意思是jni函数在运行过程中是否要进行线程的切换。

ArtMethod
  1. PrettyMethod():
    该函数可以获取JNI函数名。
    picture 1
比JNI_OnLoad执行还早的两个函数

picture 2
constructor标记的是定义该函数是在init_array当中注册的。init_array比init执行慢一点，可以在init_array可以放一堆函数，而_init只能注册一个函数。
picture 3
constructor还可以标记注册顺序。
picture 4

JavaVM

JavaVM是虚拟机在JNI层的代表，一个进程只有一个JavaVM,所有的线程共用一个JavaVM。

  1. JNIInvokeInterface_结构封装和JVM相关的功能函数，如销毁JVM，获得当前线程的Java执行环境。
  2. 在C和C++中JavaVM的定义有所不同，在C中JavaVM是JNIInvokeInterface_类型指针，而在C++中又对JNIInvokeInterface_进行了一次封装。
获取JavaVM

  1. 在JNI_OnLoad中作为参数获得，该函数由ART负责自动化查找和传入参数进行调用。
    picture 5

  2. 通过JNIEnv的GetJavaVM函数来获取。
    picture 6

获取JNIEnv
  1. 如果当前线程已绑定了一个JNIEnv，可以通过JavaVM获取
    1
    2
    3
    4
    JNIEnv* env;
    if (vm->GetEnv((void**)&env, JNI_VERSION_1_6)==JNI_OK){
      ...
    }
  2. 通过JNI函数的参数传入获取，对于任何一个JNI函数来说，第一个参数都是JNIEnv指针
  3. 在非主线程中时，需要通过当前进程的JavaVM调用AttachCurrentThread(&env, NULL)来获取。（获取代码可参考第一个方法）

tips:

  1. JNIEnv是与一个ClassLoader绑定的，当使用env->FindClass()进行类的查询和加载时，便是使用这个ClassLoader。
  2. JNIEnv是当前Java线程的执行环境，一个JVM对应一个JavaVM结构，而一个JVM中可能创建多个Java线程，使用pthread_create新建的线程当使用AttachCurrentThread来获取JNIEnv后，该JNIEnv的ClassLoader并不是主线程的ClassLoader,因此无法加载App自己的Class
全局引用、局部引用、弱全局引用
局部引用

通过NewLocalRef和各种JNI接口创建（FindClass、NewObject、GetObjectClass、NewCharArray等）。会阻止GC回收所引用的对象。局部引用只能在当前函数中使用，函数返回后局部引用所引用的对象会被JVM自动释放，或调用DeleteLocalRef手动释放。 因此，局部引用不能跨函数使用，不能跨线程使用。

tips:
Java层函数在调用本地jni代码的时候，会维护一个局部引用表(该引用表并不是无限的)，一般jni函数调用结束后，ART会释放这个引用,如果是简单的函数就不需要注意这些问题，让他自己释放，基本没有什么问题,但是如果函数里面有诸如大量的循环的操作的话，那么程序可能就会因为局部引用太多而出现异常情况。

局部引用的管理
  1. 函数返回时自动释放
  2. 手动调用deleteLocalRef释放
  3. 使用JNI提供的一系列函数来管理局部引用的生命周期。（这些函数包括EnsureLocalCapacity、NewLocalRef、PushLocalFrame、PopLocalFrame、DeleteLocalRef）。
全局引用

调用NewGlobalRef基于局部引用创建，会阻止GC回收所引用的对象。全局引用可以跨函数、跨线程使用。ART不会自动释放，必须调用DeleteGlobalRef手动释放DeleteGlobalRef(g_cls_string),否则会出现内存泄漏。

picture 3

弱全局引用

3、弱全局引用:调用NewWeakGlobalRef基于局部或全局引用创建，不会阻止Gc回收所引用的对象，可以跨方法、跨线程使用。但与全局引用很重要不同的一点是，弱引用不会阻止GC回收它引用的对象。但是引用也不会自动释放，在ART认为应该回收它的时候（比如内存紧张的时候）进行回收而被释放，或调用DeleteWeakGlobalRef手动释放。

展开全文 >>

unicorn学习

相关接口

内存相关
  1. uc_mem_map
  2. uc_mem_read
  3. uc_mem_write
寄存器相关
  1. uc_reg_read
  2. uc_reg_write
指令执行类
  1. UC_HOOK_INTR
  2. UC_HOOK_INSN
  3. UC_HOOK_CODE
  4. UC_HOOK_BLOCK
内存访问类
  1. UC_HOOK_MEM_READ
  2. UC_HOOK_MEM_WRITE
  3. UC_HOOK_MEM_FETCH

….

异常处理类
  1. UC_HOOK_MEM_READ_UNMAPPED
  2. UC_HOOK_MEM_WRITE_UNMAPPED
  3. UC_HOOK_MEM_FETCH_UNMAPPED

展开全文 >>

ARM汇编语言文档学习

ARM 处理器是典型的 RISC 处理器，因为它们执行的是加载/存储体系结构。只
有加载和存储指令才能访问内存。数据处理指令只操作寄存器的内容。

ARM、Thumb 和 ThumbEE 状态

正执行 ARM 指令的处理器在 ARM 状态 下工作。正执行 Thumb 指令的处理器在
Thumb 状态 下工作。在其中一种状态下工作的处理器不能执行不同指令集内的指令。例如，处于ARM 状态下的处理器不能执行 Thumb 指令，而处于 Thumb 状态下的处理器不能执行 ARM 指令。

更改状态

每种指令集都包含用于更改处理器状态的指令。
若要在 ARM 和 Thumb 状态之间进行转换，必须切换汇编程序模式，以便使用ARM 或 THUMB 指令生成正确的操作代码。若要生成 Thumb-2EE 代码，请使用THUMBX。

处理器模式

ARM 处理器支持不同的处理器模式，具体取决于体系结构的版本
picture 1
除用户模式之外，其他所有模式统称为特权模式。它们具有对系统资源的完全访问权限，并可随意更改模式。

需要任务保护的应用程序通常在用户模式下执行。有些嵌入式应用程序可能完全运行在超级用户模式或系统模式下。

寄存器

ARM 处理器拥有 37 个寄存器。这些寄存器按部分重叠组方式加以排列。每个处理器模式都有一个不同的寄存器组。编组的寄存器为处理处理器异常和特权操作提供了快速的上下文切换。

通用寄存器

在任一时刻都存在十五个通用寄存器，即 r0、r1… r13、r14，具体取决于当前的处理器模式。

r13

r13 是堆栈指针 (sp)。 C 和 C++ 编译器始终将 r13 用作堆栈指针。在 Thumb-2 中，sp 被严格定义为堆栈指针，因此如果使用 r13，则在堆栈操作中用处不大的许多指令会产生不可预测的结果。

r14

在用户模式下，r14 被用作链接寄存器 (lr)，用于存储调用子例程时的返回地址。如果返回地址存储在堆栈上，则也可将 r14 用作通用寄存器。

在异常处理模式下，r14 存放异常的返回地址；如果在一个异常内执行子例程调用，则 r14 存放子例程的返回地址。如果返回地址存储在堆栈上，则可将 r14 用
作通用寄存器。

程序计数器 (pc)

程序计数器被当作 r15（或 pc）来加以访问。它在 ARM 状态下以一个字（四字节）为增量，在 Thumb 状态下则按指令的大小执行。跳转指令将目标地址加载到 pc 中。可以使用数据操作指令来直接加载 PC。

执行期间，当前执行指令的地址

在执行期间，r15 (pc) 不包含当前执行的指令的地址。在 ARM 状态下，当前执行的指令的地址通常是 pc-8，而在 Thumb 状态下通常是 pc-4。

应用程序状态寄存器(APSR)

APSR存放算术逻辑单元 (ALU) 状态标记的副本。这些标记用于确定是否执行条件指令。

在 ARMv5TE 和 ARMv6 及更高版本中，APSR 还存放 Q 标记。

在 ARMv6 及更高版本中，APSR 还存放 GE 标记。

可在所有模式下使用 MSR 和 MRS 指令访问这些标记。

当前程序状态寄存器 (CPSR)

CPSR 存放下列内容：

  • APSR 标记
  • 当前处理器模式
  • 中断禁用标记。

在支持 Thumb 或 Jazelle® 的处理器上，CPSR 还存放当前处理器状态（ARM、Thumb、ThumbEE 或 Jazelle）。

在 ARMv6T2 及更高版本中，Thumb-2 为 CPSR 引入了新的状态位。IT 指令使用这些位来控制 IT 块的条件执行.

在所有模式下均可访问的标记只有 APSR 标记。对于 CPSR 的其余位，只能在特权模式下使用 MSR 和 MRS 指令访问它们。

保存的程序状态寄存器 (SPSR)

当发生异常时，使用 SPSR 来存储 CPSR。在每种异常处理模式下，可访问一个SPSR。用户模式和系统模式没有 SPSR，因为二者不是异常处理模式。

指令集

所有 ARM 指令的长度都是 32 位。这些指令是按字对齐方式存储的，因此在ARM 状态下，指令地址的两个最低有效位始终为零。

Thumb、Thumb-2 和 Thumb-2EE 指令的长度是 16 位或 32 位。这些指令按半字对齐方式存储。其中有些指令使用最低有效位来确定跳转到的目标代码是 Thumb 代码还是 ARM 代码。

在引入 Thumb-2 之前，Thumb 指令集只是 ARM 指令集功能的一个限定的子集。几乎所有 Thumb 指令都是 16 位。 Thumb-2 指令集的功能与 ARM 指令集的功能几乎相同。

ARM 和 Thumb 指令可划分为多个功能组

  1. 跳转指令
    此类指令用于：
  • 向后跳转以构成循环
  • 在条件结构中向前跳转
  • 跳转到子例程
  • 在 ARM 状态和 Thumb 状态之间转换处理器状态。
  1. 数据处理指令

此类指令用于对通用寄存器执行运算。它们可对两个寄存器的内容执行加法、减法或按位逻辑等运算，并将结果存放到第三个寄存器中。此外，它们还可以对单个寄存器中的值执行运算，或者对寄存器中的值与指令中提供的常数（立即值）执行运算。

长乘指令用两个寄存器提供 64 位的结果。

  1. 寄存器加载和存储指令

    此类指令用于从内存加载单个寄存器的值，或者在内存中存储单个寄存器的值。它们可加载或存储 32 位字、16 位半字或 8 位无符号字节。可以用符号或零扩展字节和半字加载以填充 32 位寄存器。

还定义了几个可将 64 位双字值加载或存储到两个 32 位寄存器的指令。

  1. 多个寄存器加载和存储指令

此类指令可从内存加载通用寄存器的任何子集，或者在内存中存储这样的子集。

  1. 状态寄存器访问指令
    此类指令向通用寄存器或者从通用寄存器往外移动状态寄存器的内容。

  2. 协处理器指令
    此类指令支持一种用于扩展 ARM 体系结构的通用方式。

指令功能

  1. 条件执行
    可以根据 APSR 中 ALU 状态标记的值，有条件地执行几乎所有 ARM 指令。虽然不需要使用跳转来跳过条件指令，但当一系列指令依赖于相同的条件时，这样做的效果会更好。

    在没有 Thumb-2 的处理器上的 Thumb 状态下，条件跳转是提供条件执行的唯一机制。大多数数据处理指令会更新 ALU 标记。通常不能指定指令是否更新 ALU 标记的状态。

    Thumb-2 通过使用 IT (If-Then) 指令和同样的 ALU 标记为条件执行提供了另一种机制。IT 是一个 16 位指令，最多可为后面的四个指令提供条件执行。

    在 ARM 和 Thumb-2 代码中，可以指定数据处理指令是否更新 ALU 标记。可以使用一个指令所设置的标记来控制其他指令的执行，即使在它们之间有很多非标记设置指令也是如此。

    在 ARM 状态下以及具有 Thumb-2 的处理器上的 Thumb 状态下，大多数数据处理指令都具有一个选项，该选项可根据运算结果来更新应用程序状态寄存器(APSR) 中的 ALU 状态标记。有些指令会更新所有标记，而有些指令仅更新部分标记。如果某一标记未得到更新，则会保留其原始值。每个指令的描述详细介绍了它对这些标记所具有的影响。未执行的条件指令对这些标记没有影响。

    在 ARM 状态下以及具有 Thumb-2 的处理器上的 Thumb 状态下，可以根据其他指令中设置的 ALU 状态标记有条件地执行指令

    执行时间为：

    • 在更新这些标记的指令后立即执行

    • 在尚未更新这些标记的任何数目的插入指令之后执行。

      可以根据 APSR 中的 ALU 状态标记的状态有条件地执行几乎所有 ARM 指令。下图为条件代码后缀
      picture 2

      在 Thumb 状态下，使用条件跳转是一种条件执行机制。

      在具有 Thumb-2 的处理器上的 Thumb 状态下，可以使用特殊的 IT (If-Then) 指令使指令有条件地执行。此外，还可以使用 CBZ（零条件跳转）和 CBNZ 指令将寄存器值与零进行比较。

  2. 寄存器访问

在 ARM 状态下，所有指令都可访问 r0 到 r14，并且大多数指令也可访问 r15 (pc)**。MRS 和 MSR 指令可将状态寄存器的内容移到通用寄存器中**，在通用寄存器中可以用普通的数据处理操作来处理这些内容。

Thumb-2 处理器上的 Thumb 状态提供了同样的功能，但会禁止一些对 r13 和 r15 的无用访问。

在没有 Thumb-2 的处理器上的 Thumb 状态下，大多数指令只能访问 r0 到 r7。只有少数指令能够访问 r8 到 r15。**寄存器 r0 到 r7 称为低位寄存器。寄存器 r8 到r15 称为高位寄存器**。

  1. 访问内联的滚筒式移位器
    ARM 算术逻辑单元具有一个 32 位滚筒式移位器，可执行移位和循环操作。

    对于所有 ARM 和 Thumb-2 数据处理指令和单寄存器数据传送指令的第二个操作数，可以在执行数据处理或数据传送之前，将其作为指令的一部分执行移位操作。
    此操作支持（但不限于）：

    • 比例寻址

    • 乘以一个常数

    • 构造常数。

      Thumb-2 指令与 ARM 指令对滚筒式移位器的访问方式几乎相同。

      16 位 Thumb 指令集只允许使用单独的指令来访问滚筒式移位器。

MSR（用于存储）

将 PSR 的内容移到通用寄存器中

语法

MRS{cond} Rd, psr

cond: 是一个可选的条件代码
Rd: 是目标寄存器。Rd 不能为 r15(pc)。
psr: 是下列项之一:

  1. APSR 任何处理器，任何模式。
  2. CPSR 推荐使用的 APSR 的同义词，用于调试状态。
  3. SPSR 除 ARMv7-M 外的任何处理器，仅可用于特权模式。
  4. MpSR 仅用于 ARMv7-M 处理器。

Mpsr: 是下列项之一：
IPSR、EPSR、IEPSR、IAPSR、EAPSR、PSR、MSP、PSP、DSP、
PRIMASK、BASEPRI、BASEPRI_MAX 或 CONTROL

用法

可将 MRS 与 MSR 结合使用，创建一个更新 PSR 的读- 改- 写序列，例如更改处理器模式或清除 Q 标记。

在进程交换代码中，必须保存程序员的换出进程的模型状态，包括 PSR 的相关内容。同样，也必须恢复换入进程的状态。这些操作使用的是 MRS/存储和加载/MSR 指令序列。

注意：

  1. 当处理器处于用户或系统模式时，请不要访问 SPSR。这是您的责任。汇编程序无法就此发出警告，因为它不知道执行过程中的处理器模式。如果在处理器处于用户模式或系统模式时，尝试访问 SPSR，则结果将是无法预料的。

  2. 仅当处理器处于调试状态、暂停调试模式时，才能读取 CPSR 执行状态位。否则，CPSR 中的执行状态位的读取结果将会为零。条件标记的读取不受模式和处理器的限制。应使用 APSR，而不是 CPSR。

  3. 此指令不更改标记。

  4. 此 ARM 指令可用于所有版本的 ARM 体系结构。这些 32 位 Thumb 指令可用于 ARMv6T2 和 ARMv7。此指令无 16 位 Thumb 版本。

MSR（用于加载）

将通用寄存器的立即数或内容加载到程序状态寄存器 (PSR) 的指定位段中。

语法（ARMv7-M 除外）

MSR{cond} APSR_flags, #constant

MSR{cond} APSR_flags, Rm

MSR{cond} psr_fields, #constant

MSR{cond} psr_fields, Rm

其中：
cond: 是一个可选的条件代码
flags: 指定要移动的 APSR 标记。flags 可以是以下的一个或多个指令：

  • nzcvq ALU 可标记位段掩码，PSR[31:27]（用户模式）
  • g SIMD GE 可标记位段掩码，PSR[19:16]（用户模式）。

constant: 是取值为常数的一个表达式。该常数必须对应于一个 8 位结构，可通过在 32 位字内循环移动偶数位而得到。在 Thumb 中不可用。

Rm: 是源寄存器。
psr: 是下列项之一:

  • CPSR 用于调试状态，请不要将其看做 APSR 的同义词
  • SPSR 仅可用于特权模式下的处理器。

fields: 指定要移动的 SPSR 或 CPSR 位段。fields 可以是以下一个或多个值:

  • c 控制位段掩码字节，PSR[7:0]（特权模式）
  • x 扩展位段掩码字节，PSR[15:8]（特权模式）
  • s 状态位段掩码字节，PSR[23:16]（特权模式）
  • f 标记位段掩码字节，PSR[31:24]（特权模式）。
语法 (ARMv7-M)

MSR{cond} psr, Rm

cond: 是一个可选的条件代码
Rm: 是源寄存器。
psr: 是下列项之一：APSR、IPSR、EPSR、IEPSR、IAPSR、EAPSR、PSR、MSP、PSP、DSP、PRIMASK、BASEPRI、BASEPRI_MAX 或 CONTROL。仅限 ARMv7-M。

用法与MRS相同

在用户模式中：

  • 使用 APSR 访问条件标记、Q 或 GE 位。
  • 忽略对 CPSR 中的未分配状态位、特权状态位或执行状态位的写入。这可确保用户模式程序不会更改为 特权模式。

如果在用户或系统模式时尝试访问 SPSR，则结果将是无法预料的。

注意：

  1. 如果指定了 APSR_nzcvq 或 CPSR_f 位段，则此指令将会显式更新标记。
  2. 此 ARM 指令可用于所有版本的 ARM 体系结构。这些 32 位 Thumb 指令可用于 ARMv6T2 和 ARMv7。此指令无 16 位 Thumb 版本。

汇编语言模块的结构

汇编语言是指 ARM 汇编程序 (armasm) 进行分析并汇编生成对象代码的语言。缺省情况下，汇编程序应使用 ARM 汇编语言编写源代码。

armasm 支持用旧版本的 ARM 汇编语言编写的源代码。在这种情况下，它无需获得相应的通知。

armasm 还可支持用旧版本的 Thumb 汇编语言编写的源代码。在这种情况下，必须在源代码中使用 –16 命令行选项或 CODE16 指令通知 armasm。旧版本的 Thumb 汇编语言不支持 Thumb-2 指令。

语法格式

汇编语言的源代码行的一般格式是
{label} {instruction|directive|pseudo-instruction} {;comment}

下图为官方的arm汇编示例
picture 1

注意：

  1. 即使没有标签，指令、伪指令和指令前面也必须使用空格或制表符等留出空白。

  2. 源代码行的所有三部分都是可选的。使用空行可使代码更具可读性。

大小写规则

指令助记符、指令和符号寄存器名称可以用大写或小写编写，但不能混合使用大小写。

行长度的最大值为 4095 个字符，包括使用反斜杠的任何扩展在内。

ELF节

ELF 节 是独立的、已命名的、不可分割的代码或数据序列。单个代码节是生成应用程序的最低要求。

汇编或编译的输出内容可包括：

  • 一个或多个代码节。它们通常是只读节。
  • 一个或多个数据节。它们通常是读写节。它们可以是零初始化的 (ZI)。

链接器依照节位置规则，将每个节放在一个程序映像中。对于在源文件中相邻的节，在应用程序映像中不一定相邻。

AREA

在源文件中，AREA 指令标记一节的开始。该指令对节进行命名并设置其属性。属性放在名称后面，之间用逗号分隔。

可以为节选择任何名称。但是，以任何非字母字符开头的名称必须括在竖线内，否则会生成 AREA name missing 错误。例如，|1_DataArea|。

ENTRY 指令

ENTRY 指令标记的是第一个要执行的指令。在包含 C 代码的应用程序中，在 C 库初始化代码中也包含一个入口点。初始化代码和异常处理程序也包含入口点。

应用程序执行（start）

应用程序代码在标签 start 处开始执行，
官方示例图中
picture 1
start开始并将
进制值 10 和 3 加载到寄存器 r0 和 r1 中。这些寄存器将一起相加，并且结果将存放到 r0 中。

应用程序终止（stop）

在执行主代码后，应用程序会将控制权返回调试器，以此来终止执行。

END指令

此指令指示汇编程序停止处理此源文件。每个汇编语言源模块必须以仅包括 END指令的一行结束。

调用子例程

若要调用子例程，应使用跳转和链接指令，其语法是：
BL destination
其中，destination 通常是位于子例程的第一个指令处的标签。destination 也可以是程序相对表达式。

BL 指令

作用：

  • 将返回地址存放到链接寄存器中
  • 将 pc 设置为子例程的地址。

在执行子例程代码后，可以使用 BX lr 指令返回。按照约定，寄存器 r0 到 r3 用于将参数传递给子例程，并且 r0 还用于将结果传递回调用方。

Q标记

在 ARMv5TE 和 ARMv6 及更高版本中，当饱和算术指令（在 ARMv5TE 和 ARMv6 及更高版本中，当饱和算术指令）中出现饱和或某些乘法指令（SMULxy 和 SMLAxy 和第4-79 页的SMULWy 和 SMLAWy）中出现溢出时，会记录 Q 标记。

Q 标记是一种粘性 标记。虽然这些指令可以设置该标记，但不能清除它。

要清除 Q 标记，则请使用 MSR 指令

不能直接用条件代码来测试 Q 标记的状态。若要读取 Q 标记的状态，请使用 MRS指令

展开全文 >>

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到爬虫未来将会到安全的软件工程师。