tls

log.txt

0 read chunk <Buffer 16 03 01 00 e1 01 00 00 dd 03 03 61 37 fb 11 ba 72 be 4e ac 79 4d d4 0b d4 a8 9a c4 3d b7 aa 9e ca 53 94 5a 1d 77 54 ee b7 79 5f 20 e8 b5 bf f8 93 8f ... 180 more bytes>
0 read immediately DataBuffer {
  appendOffset: 230,
  readOffset: 0,
  data: <Buffer 16 03 01 00 e1 01 00 00 dd 03 03 61 37 fb 11 ba 72 be 4e ac 79 4d d4 0b d4 a8 9a c4 3d b7 aa 9e ca 53 94 5a 1d 77 54 ee b7 79 5f 20 e8 b5 bf f8 93 8f ... 180 more bytes>
}
0 read encrypted DataBuffer {
  appendOffset: 230,
  readOffset: 0,
  data: <Buffer 16 03 01 00 e1 01 00 00 dd 03 03 61 37 fb 11 ba 72 be 4e ac 79 4d d4 0b d4 a8 9a c4 3d b7 aa 9e ca 53 94 5a 1d 77 54 ee b7 79 5f 20 e8 b5 bf f8 93 8f ... 180 more bytes>
}
0 read handshake buffer DataBuffer {
  appendOffset: 230,
  readOffset: 0,
  data: <Buffer 16 03 01 00 e1 01 00 00 dd 03 03 61 37 fb 11 ba 72 be 4e ac 79 4d d4 0b d4 a8 9a c4 3d b7 aa 9e ca 53 94 5a 1d 77 54 ee b7 79 5f 20 e8 b5 bf f8 93 8f ... 180 more bytes>
}

1 write handshake buffer DataBuffer {
  appendOffset: 2275,
  readOffset: 0,
  data: <Buffer 16 03 03 00 5b 02 00 00 57 03 03 65 0c 6a 4f e1 ba df 63 0e 84 7b df 85 9a 44 31 a9 fa bd d8 d1 29 3d de 6d 1d 64 69 28 0a 5e ab 20 30 6f f9 f4 7b 21 ... 2225 more bytes>
}
1 write encrypted DataBuffer {
  appendOffset: 2275,
  readOffset: 0,
  data: <Buffer 16 03 03 00 5b 02 00 00 57 03 03 65 0c 6a 4f e1 ba df 63 0e 84 7b df 85 9a 44 31 a9 fa bd d8 d1 29 3d de 6d 1d 64 69 28 0a 5e ab 20 30 6f f9 f4 7b 21 ... 2225 more bytes>
}
1 starting write

2 read chunk <Buffer 16 03 03 03 38 0b 00 03 34 00 03 31 00 03 2e 30 82 03 2a 30 82 02 12 02 01 1b 30 0d 06 09 2a 86 48 86 f7 0d 01 01 0b 05 00 30 5b 31 0b 30 09 06 03 55 ... 1141 more bytes>
2 read immediately DataBuffer {
  appendOffset: 1191,
  readOffset: 0,
  data: <Buffer 16 03 03 03 38 0b 00 03 34 00 03 31 00 03 2e 30 82 03 2a 30 82 02 12 02 01 1b 30 0d 06 09 2a 86 48 86 f7 0d 01 01 0b 05 00 30 5b 31 0b 30 09 06 03 55 ... 1141 more bytes>
}
2 read encrypted DataBuffer {
  appendOffset: 1191,
  readOffset: 0,
  data: <Buffer 16 03 03 03 38 0b 00 03 34 00 03 31 00 03 2e 30 82 03 2a 30 82 02 12 02 01 1b 30 0d 06 09 2a 86 48 86 f7 0d 01 01 0b 05 00 30 5b 31 0b 30 09 06 03 55 ... 1141 more bytes>
}
2 read handshake buffer DataBuffer {
  appendOffset: 1191,
  readOffset: 0,
  data: <Buffer 16 03 03 03 38 0b 00 03 34 00 03 31 00 03 2e 30 82 03 2a 30 82 02 12 02 01 1b 30 0d 06 09 2a 86 48 86 f7 0d 01 01 0b 05 00 30 5b 31 0b 30 09 06 03 55 ... 1141 more bytes>
}
1 finished write

3 write handshake buffer DataBuffer {
  appendOffset: 51,
  readOffset: 0,
  data: <Buffer 14 03 03 00 01 01 16 03 03 00 28 00 00 00 00 00 00 00 00 67 3a d4 fe 48 4b 15 27 c2 c0 b9 ff 6c b6 dc 98 08 ef 2a 9e 26 27 41 41 c8 b5 e3 c5 d9 e0 7f ... 1 more byte>
}
3 write encrypted DataBuffer {
  appendOffset: 51,
  readOffset: 0,
  data: <Buffer 14 03 03 00 01 01 16 03 03 00 28 00 00 00 00 00 00 00 00 67 3a d4 fe 48 4b 15 27 c2 c0 b9 ff 6c b6 dc 98 08 ef 2a 9e 26 27 41 41 c8 b5 e3 c5 d9 e0 7f ... 1 more byte>
}
3 starting write
connected, cipher: ECDHE-RSA-AES128-GCM-SHA256 TLSv1/SSLv3
3 finished write

4 decrypt DataBuffer {
  appendOffset: 916,
  readOffset: 0,
  data: <Buffer 17 03 03 03 8f 00 00 00 00 00 00 00 01 8a e2 c8 1e 08 01 51 9e d6 db cc b8 16 fa c6 9a 6c 79 49 1b 2f 0e 5b 3a f8 52 5c 74 d9 ee 5b 36 d3 2a e6 6c 04 ... 866 more bytes>
}
4 write encrypted DataBuffer {
  appendOffset: 916,
  readOffset: 0,
  data: <Buffer 17 03 03 03 8f 00 00 00 00 00 00 00 01 8a e2 c8 1e 08 01 51 9e d6 db cc b8 16 fa c6 9a 6c 79 49 1b 2f 0e 5b 3a f8 52 5c 74 d9 ee 5b 36 d3 2a e6 6c 04 ... 866 more bytes>
}
4 starting write
4 finished write
4 read chunk <Buffer 00 05 0a 98 01 89 50 4e 47 0d 0a 1a 0a 00 00 00 0d 49 48 44 52 00 00 00 20 00 00 00 20 01 03 00 00 00 49 b4 e8 b7 00 00 00 06 50 4c 54 45 a4 c6 39 a4 ... 837 more bytes>
4 read immediately DataBuffer {
  appendOffset: 887,
  readOffset: 0,
  data: <Buffer 00 05 0a 98 01 89 50 4e 47 0d 0a 1a 0a 00 00 00 0d 49 48 44 52 00 00 00 20 00 00 00 20 01 03 00 00 00 49 b4 e8 b7 00 00 00 06 50 4c 54 45 a4 c6 39 a4 ... 837 more bytes>
}
4 read cleartext DataBuffer {
  appendOffset: 887,
  readOffset: 0,
  data: <Buffer 00 05 0a 98 01 89 50 4e 47 0d 0a 1a 0a 00 00 00 0d 49 48 44 52 00 00 00 20 00 00 00 20 01 03 00 00 00 49 b4 e8 b7 00 00 00 06 50 4c 54 45 a4 c6 39 a4 ... 837 more bytes>
}
Discovery request, brand: motorola edge 30 ultra, device name Android

5 encrypt DataBuffer {
  appendOffset: 238,
  readOffset: 0,
  data: <Buffer 00 06 0a 0f 08 07 2a 0b 08 01 12 07 08 80 7d 10 10 18 01 0a 14 08 04 1a 10 08 01 10 03 1a 08 08 80 f7 02 10 10 18 02 28 01 0a 13 08 05 1a 0f 08 01 10 ... 188 more bytes>
}
5 write cleartext DataBuffer {
  appendOffset: 238,
  readOffset: 0,
  data: <Buffer 00 06 0a 0f 08 07 2a 0b 08 01 12 07 08 80 7d 10 10 18 01 0a 14 08 04 1a 10 08 01 10 03 1a 08 08 80 f7 02 10 10 18 02 28 01 0a 13 08 05 1a 0f 08 01 10 ... 188 more bytes>
}
5 starting write
5 finished write
5 read chunk <Buffer 17 03 03 01 06 00 00 00 00 00 00 00 01 1a 81 d6 03 fc 5c 22 bb 0c 1d 5f dd 62 1a f3 c5 9b f6 e2 49 24 6b 8c d7 dd 36 b9 8f a2 b0 87 66 19 5a 1a 81 17 ... 217 more bytes>
5 read immediately DataBuffer {
  appendOffset: 267,
  readOffset: 0,
  data: <Buffer 17 03 03 01 06 00 00 00 00 00 00 00 01 1a 81 d6 03 fc 5c 22 bb 0c 1d 5f dd 62 1a f3 c5 9b f6 e2 49 24 6b 8c d7 dd 36 b9 8f a2 b0 87 66 19 5a 1a 81 17 ... 217 more bytes>
}
5 read encrypted DataBuffer {
  appendOffset: 267,
  readOffset: 0,
  data: <Buffer 17 03 03 01 06 00 00 00 00 00 00 00 01 1a 81 d6 03 fc 5c 22 bb 0c 1d 5f dd 62 1a f3 c5 9b f6 e2 49 24 6b 8c d7 dd 36 b9 8f a2 b0 87 66 19 5a 1a 81 17 ... 217 more bytes>
}

6 decrypt DataBuffer {
  appendOffset: 33,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1c 00 00 00 00 00 00 00 02 40 27 ca 16 18 b1 0f a7 2b 7a 87 3b 43 38 58 19 63 1c 81 b7>
}
6 write encrypted DataBuffer {
  appendOffset: 33,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1c 00 00 00 00 00 00 00 02 40 27 ca 16 18 b1 0f a7 2b 7a 87 3b 43 38 58 19 63 1c 81 b7>
}
6 starting write
6 finished write
6 read chunk <Buffer 00 12 08 04>
6 read immediately DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 12 08 04>
}
6 read cleartext DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 12 08 04>
}

7 encrypt DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 13 08 03>
}
7 write cleartext DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 13 08 03>
}
7 starting write
7 finished write
7 read chunk <Buffer 17 03 03 00 1c 00 00 00 00 00 00 00 02 5b 3d 35 66 3b 75 a2 a6 a5 72 13 05 59 9f 6e 9d ac 02 13 9a>
7 read immediately DataBuffer {
  appendOffset: 33,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1c 00 00 00 00 00 00 00 02 5b 3d 35 66 3b 75 a2 a6 a5 72 13 05 59 9f 6e 9d ac 02 13 9a>
}
7 read encrypted DataBuffer {
  appendOffset: 33,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1c 00 00 00 00 00 00 00 02 5b 3d 35 66 3b 75 a2 a6 a5 72 13 05 59 9f 6e 9d ac 02 13 9a>
}

8 decrypt DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 03 32 77 2b 04 d3 e9 da 47 4e 3d 4f 34 bb 54 63 65 cb 4a d8 c3 37 35>
}
8 write encrypted DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 03 32 77 2b 04 d3 e9 da 47 4e 3d 4f 34 bb 54 63 65 cb 4a d8 c3 37 35>
}
8 starting write
8 finished write
8 read chunk <Buffer 00 07 08 00 10 07>
8 read immediately DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 07>
}
8 read cleartext DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 07>
}

9 encrypt DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
9 write cleartext DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
9 starting write

10 decrypt DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 04 7d e6 86 f5 62 8f 64 f3 dc 9f aa 99 b0 11 02 37 28 d6 f7 66 2a c3>
}
10 write encrypted DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 04 7d e6 86 f5 62 8f 64 f3 dc 9f aa 99 b0 11 02 37 28 d6 f7 66 2a c3>
}
10 starting write
10 finished write
10 read chunk <Buffer 00 07 08 00 10 04>
10 read immediately DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 04>
}
10 read cleartext DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 04>
}

11 encrypt DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
11 write cleartext DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
11 starting write

12 decrypt DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 05 f7 80 67 ef 69 fa e8 8c 02 cc f2 3a df 3d a1 e6 f2 66 a9 b3 90 be>
}
12 write encrypted DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 05 f7 80 67 ef 69 fa e8 8c 02 cc f2 3a df 3d a1 e6 f2 66 a9 b3 90 be>
}
12 starting write
12 finished write
12 read chunk <Buffer 00 07 08 00 10 05>
12 read immediately DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 05>
}
12 read cleartext DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 05>
}

13 encrypt DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
13 write cleartext DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
13 starting write

14 decrypt DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 06 5e 14 32 aa d2 ac e3 61 73 1b d9 58 71 33 40 d7 2a 2f 0b 16 f5 22>
}
14 write encrypted DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 06 5e 14 32 aa d2 ac e3 61 73 1b d9 58 71 33 40 d7 2a 2f 0b 16 f5 22>
}
14 starting write
14 finished write
14 read chunk <Buffer 00 07 08 00 10 06>
14 read immediately DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 06>
}
14 read cleartext DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 06>
}

15 encrypt DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
15 write cleartext DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
15 starting write

16 decrypt DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 07 e1 f3 00 9f 26 b2 c4 3f 0a 0e e2 6d 99 b1 2c ef 83 fc c6 a5 89 da>
}
16 write encrypted DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 07 e1 f3 00 9f 26 b2 c4 3f 0a 0e e2 6d 99 b1 2c ef 83 fc c6 a5 89 da>
}
16 starting write
16 finished write
16 read chunk <Buffer 00 07 08 00 10 02>
16 read immediately DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 02>
}
16 read cleartext DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 02>
}

17 encrypt DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
17 write cleartext DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
17 starting write

18 decrypt DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 08 bd 55 00 a5 78 ea f4 0b d7 85 7e 3a c5 17 4d c0 44 a9 53 60 42 fa>
}
18 write encrypted DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 08 bd 55 00 a5 78 ea f4 0b d7 85 7e 3a c5 17 4d c0 44 a9 53 60 42 fa>
}
18 starting write
18 finished write
18 read chunk <Buffer 00 07 08 00 10 09>
18 read immediately DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 09>
}
18 read cleartext DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 09>
}

19 encrypt DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
19 write cleartext DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
19 starting write

20 decrypt DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 09 cf ea 00 cb d0 04 2e d6 70 ac 16 4f 4b 6f a5 5b 37 0f 2e ca ed ba>
}
20 write encrypted DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 09 cf ea 00 cb d0 04 2e d6 70 ac 16 4f 4b 6f a5 5b 37 0f 2e ca ed ba>
}
20 starting write
20 finished write
20 read chunk <Buffer 00 07 08 00 10 0a>
20 read immediately DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 0a>
}
20 read cleartext DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 0a>
}

21 encrypt DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
21 write cleartext DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
21 starting write

22 decrypt DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 0a d5 6a d0 bc f8 d1 bd d1 96 ea a0 8b a2 f0 65 db 18 e5 b6 d9 44 33>
}
22 write encrypted DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 0a d5 6a d0 bc f8 d1 bd d1 96 ea a0 8b a2 f0 65 db 18 e5 b6 d9 44 33>
}
22 starting write
22 finished write
22 read chunk <Buffer 00 07 08 00 10 01>
22 read immediately DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 01>
}
22 read cleartext DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 01>
}

23 encrypt DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
23 write cleartext DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
23 starting write

24 decrypt DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 0b d7 b6 82 11 a4 d8 dd cd e6 80 7b c0 34 b4 a8 01 5c 9d 36 f9 f3 67>
}
24 write encrypted DataBuffer {
  appendOffset: 35,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1e 00 00 00 00 00 00 00 0b d7 b6 82 11 a4 d8 dd cd e6 80 7b c0 34 b4 a8 01 5c 9d 36 f9 f3 67>
}
24 starting write
24 finished write
24 read chunk <Buffer 00 07 08 00 10 03>
24 read immediately DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 03>
}
24 read cleartext DataBuffer {
  appendOffset: 6,
  readOffset: 0,
  data: <Buffer 00 07 08 00 10 03>
}

25 encrypt DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
25 write cleartext DataBuffer {
  appendOffset: 4,
  readOffset: 0,
  data: <Buffer 00 08 08 00>
}
25 starting write
9 finished write
9 read chunk <Buffer 17 03 03 00 1c 00 00 00 00 00 00 00 03 81 ea fb 32 a6 72 ca 85 a5 43 68 94 5e 79 be 71 40 69 1a b9 17 03 03 00 38 00 00 00 00 00 00 00 04 59 ad f1 f5 ... 44 more bytes>
9 read immediately DataBuffer {
  appendOffset: 94,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1c 00 00 00 00 00 00 00 03 81 ea fb 32 a6 72 ca 85 a5 43 68 94 5e 79 be 71 40 69 1a b9 17 03 03 00 38 00 00 00 00 00 00 00 04 59 ad f1 f5 ... 44 more bytes>
}
9 read encrypted DataBuffer {
  appendOffset: 94,
  readOffset: 0,
  data: <Buffer 17 03 03 00 1c 00 00 00 00 00 00 00 03 81 ea fb 32 a6 72 ca 85 a5 43 68 94 5e 79 be 71 40 69 1a b9 17 03 03 00 38 00 00 00 00 00 00 00 04 59 ad f1 f5 ... 44 more bytes>
}
11 finished write
13 finished write
15 finished write
17 finished write
19 finished write
21 finished write
23 finished write
25 finished write
11 read later
13 read later
15 read later
17 read later
19 read later
21 read later
23 read later
25 read later