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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
|
// +build darwin
package dhcpv4
// Implements Apple's netboot protocol BSDP (Boot Service Discovery Protocol).
// Canonical implementation is defined here:
// http://opensource.apple.com/source/bootp/bootp-198.1/Documentation/BSDP.doc
import (
"encoding/binary"
"fmt"
"syscall"
)
// Options (occur as sub-options of DHCP option 43).
const (
BSDPOptionMessageType OptionCode = iota + 1
BSDPOptionVersion
BSDPOptionServerIdentifier
BSDPOptionServerPriority
BSDPOptionReplyPort
BSDPOptionBootImageListPath // Not used
BSDPOptionDefaultBootImageID
BSDPOptionSelectedBootImageID
BSDPOptionBootImageList
BSDPOptionNetboot1_0Firmware
BSDPOptionBootImageAttributesFilterList
)
// Versions (seen so far)
var (
BSDPVersion1_0 = []byte{1, 0}
BSDPVersion1_1 = []byte{1, 1}
)
// BSDP message types
const (
BSDPMessageTypeList byte = iota + 1
BSDPMessageTypeSelect
BSDPMessageTypeFailed
)
// Boot image kinds
const (
BSDPBootImageMacOS9 byte = iota
BSDPBootImageMacOSX
BSDPBootImageMacOSXServer
BSDPBootImageHardwareDiagnostics
// 0x4 - 0x7f are reserved for future use.
)
// BootImageID describes a boot image ID - whether it's an install image and
// what kind of boot image (e.g. OS 9, macOS, hardware diagnostics)
type BootImageID struct {
isInstall bool
imageKind byte
index uint16
}
// toBytes serializes a BootImageID to network-order bytes.
func (b BootImageID) toBytes() (bytes []byte) {
bytes = make([]byte, 4)
// Attributes.
if b.isInstall {
bytes[0] |= 0x80
}
bytes[0] |= b.imageKind
// Index
binary.BigEndian.PutUint16(bytes[2:], b.index)
return
}
// BootImageIDFromBytes deserializes a collection of 4 bytes to a BootImageID.
func bootImageIDFromBytes(bytes []byte) BootImageID {
return BootImageID{
isInstall: bytes[0]&0x80 != 0,
imageKind: bytes[0] & 0x7f,
index: binary.BigEndian.Uint16(bytes[2:]),
}
}
// BootImage describes a boot image - contains the boot image ID and the name.
type BootImage struct {
ID BootImageID
// This is a utf-8 string.
Name string
}
// toBytes converts a BootImage to a slice of bytes.
func (b *BootImage) toBytes() (bytes []byte) {
idBytes := b.ID.toBytes()
bytes = append(bytes, idBytes[:]...)
bytes = append(bytes, byte(len(b.Name)))
bytes = append(bytes, []byte(b.Name)...)
return
}
// BootImageFromBytes returns a deserialized BootImage struct from bytes as well
// as the number of bytes read from the slice.
func bootImageFromBytes(bytes []byte) (*BootImage, int, error) {
// If less than length of boot image ID and count, it's probably invalid.
if len(bytes) < 5 {
return nil, 0, fmt.Errorf("not enough bytes for BootImage")
}
imageID := bootImageIDFromBytes(bytes[:4])
nameLength := int(bytes[4])
if 5+nameLength > len(bytes) {
return nil, 0, fmt.Errorf("not enough bytes for BootImage")
}
name := string(bytes[5 : 5+nameLength])
return &BootImage{ID: imageID, Name: name}, 5 + nameLength, nil
}
// makeVendorClassIdentifier calls the sysctl syscall on macOS to get the
// platform model.
func makeVendorClassIdentifier() (string, error) {
// Fetch hardware model for class ID.
hwModel, err := syscall.Sysctl("hw.model")
if err != nil {
return "", err
}
vendorClassID := fmt.Sprintf("AAPLBSDPC/i386/%s", hwModel)
return vendorClassID, nil
}
// parseBootImagesFromBSDPOption parses data from the BSDPOptionBootImageList
// option and returns a list of BootImages.
func parseBootImagesFromBSDPOption(data []byte) ([]BootImage, error) {
// Should at least have the # bytes of boot images.
if len(data) < 4 {
return nil, fmt.Errorf("invalid length boot image list")
}
readByteCount := 0
start := data
var bootImages []BootImage
for {
bootImage, readBytes, err := bootImageFromBytes(start)
if err != nil {
return nil, err
}
bootImages = append(bootImages, *bootImage)
readByteCount += readBytes
if readByteCount+1 >= len(data) {
break
}
start = start[readByteCount:]
}
return bootImages, nil
}
// parseVendorOptionsFromOptions extracts the sub-options list of the vendor-
// specific options from the larger DHCP options list.
func parseVendorOptionsFromOptions(options []Option) []Option {
var vendorOpts []Option
var err error
for _, opt := range options {
if opt.Code == OptionVendorSpecificInformation {
vendorOpts, err = OptionsFromBytes(opt.Data)
if err != nil {
return []Option{}
}
break
}
}
return vendorOpts
}
// ParseBootImageListFromAck parses the list of boot images presented in the
// ACK[LIST] packet and returns them as a list of BootImages.
func ParseBootImageListFromAck(ack DHCPv4) ([]BootImage, error) {
var bootImages []BootImage
vendorOpts := parseVendorOptionsFromOptions(ack.options)
for _, opt := range vendorOpts {
if opt.Code == BSDPOptionBootImageList {
images, err := parseBootImagesFromBSDPOption(opt.Data)
if err != nil {
return nil, err
}
bootImages = append(bootImages, images...)
}
}
return bootImages, nil
}
// NewInformListForInterface creates a new INFORM packet for interface ifname
// with configuration options specified by config.
func NewInformListForInterface(iface string, replyPort uint16) (*DHCPv4, error) {
d, err := NewInformForInterface(iface /* needsBroadcast */, false)
if err != nil {
return nil, err
}
// These are vendor-specific options used to pass along BSDP information.
vendorOpts := []Option{
Option{
Code: BSDPOptionMessageType,
Data: []byte{BSDPMessageTypeList},
},
Option{
Code: BSDPOptionVersion,
Data: BSDPVersion1_1,
},
}
// If specified, replyPort MUST be a priviledged port.
if replyPort != 0 && replyPort != ClientPort {
if replyPort >= 1024 {
return nil, fmt.Errorf("replyPort must be a priviledged port (< 1024)")
}
bytes := make([]byte, 3)
bytes[0] = 2
binary.BigEndian.PutUint16(bytes[1:], replyPort)
d.AddOption(Option{
Code: BSDPOptionReplyPort,
Data: bytes,
})
}
d.AddOption(Option{
Code: OptionVendorSpecificInformation,
Data: OptionsToBytes(vendorOpts),
})
d.AddOption(Option{
Code: OptionParameterRequestList,
Data: []byte{OptionVendorSpecificInformation, OptionClassIdentifier},
})
u16 := make([]byte, 2)
binary.BigEndian.PutUint16(u16, 1500)
d.AddOption(Option{
Code: OptionMaximumDHCPMessageSize,
Data: u16,
})
vendorClassID, err := makeVendorClassIdentifier()
if err != nil {
return nil, err
}
d.AddOption(Option{
Code: OptionClassIdentifier,
Data: []byte(vendorClassID),
})
d.AddOption(Option{Code: OptionEnd})
return d, nil
}
// InformSelectForAck constructs an INFORM[SELECT] packet given an ACK to the
// previously-sent INFORM[LIST] with BSDPConfig config.
func InformSelectForAck(ack DHCPv4, replyPort uint16, selectedImage BootImage) (*DHCPv4, error) {
d, err := New()
if err != nil {
return nil, err
}
d.SetOpcode(OpcodeBootRequest)
d.SetHwType(ack.HwType())
d.SetHwAddrLen(ack.HwAddrLen())
clientHwAddr := ack.ClientHwAddr()
d.SetClientHwAddr(clientHwAddr[:])
d.SetTransactionID(ack.TransactionID())
if ack.IsBroadcast() {
d.SetBroadcast()
} else {
d.SetUnicast()
}
// Data for BSDPOptionSelectedBootImageID
vendorOpts := []Option{
Option{
Code: BSDPOptionMessageType,
Data: []byte{BSDPMessageTypeSelect},
},
Option{
Code: BSDPOptionVersion,
Data: BSDPVersion1_1,
},
Option{
Code: BSDPOptionSelectedBootImageID,
Data: append([]byte{4}, selectedImage.ID.toBytes()...),
},
}
// Find server IP address
var serverIP []byte
for _, opt := range ack.options {
if opt.Code == OptionServerIdentifier {
serverIP = make([]byte, 4)
copy(serverIP, opt.Data)
}
}
if len(serverIP) == 0 {
return nil, fmt.Errorf("could not parse server identifier from ACK")
}
vendorOpts = append(vendorOpts, Option{
Code: BSDPOptionServerIdentifier,
Data: serverIP,
})
// Validate replyPort if requested.
if replyPort != 0 && replyPort != ClientPort {
// replyPort MUST be a priviledged port.
if replyPort >= 1024 {
return nil, fmt.Errorf("replyPort must be a priviledged port")
}
bytes := make([]byte, 3)
bytes[0] = 2
binary.BigEndian.PutUint16(bytes[1:], replyPort)
vendorOpts = append(vendorOpts, Option{
Code: BSDPOptionReplyPort,
Data: bytes,
})
}
d.AddOption(Option{
Code: OptionDHCPMessageType,
Data: []byte{MessageTypeInform},
})
d.AddOption(Option{
Code: OptionVendorSpecificInformation,
Data: OptionsToBytes(vendorOpts),
})
d.AddOption(Option{Code: OptionEnd})
return d, nil
}
|