Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1# Impacket - Collection of Python classes for working with network protocols. 

2# 

3# SECUREAUTH LABS. Copyright (C) 2021 SecureAuth Corporation. All rights reserved. 

4# 

5# This software is provided under a slightly modified version 

6# of the Apache Software License. See the accompanying LICENSE file 

7# for more information. 

8# 

9# Description: 

10# IEEE 802.11 Network packet codecs. 

11# 

12# Author: 

13# Gustavo Moreira 

14# 

15 

16import struct 

17from binascii import crc32 

18 

19from impacket.ImpactPacket import ProtocolPacket, array_tobytes 

20from impacket.Dot11Crypto import RC4 

21frequency = { 

22 2412: 1, 2417: 2, 2422: 3, 2427: 4, 2432: 5, 2437: 6, 2442: 7, 2447: 8, 2452: 9, 

23 2457: 10, 2462: 11, 2467: 12, 2472: 13, 2484: 14, 5170: 34, 5180: 36, 5190: 38, 5200: 40, 

24 5210: 42, 5220: 44, 5230: 46, 5240: 48, 5260: 52, 5280: 56, 5300: 60, 5320: 64, 5500: 100, 

25 5510: 102, 5520: 104, 5530: 106, 5540: 108, 5550: 110, 5560: 112, 5570: 114, 5580: 116, 5590: 118, 

26 5600: 120, 5610: 122, 5620: 124, 5630: 126, 5640: 128, 5650: 130, 5660: 132, 5670: 134, 5680: 136, 

27 5690: 138, 5700: 140, 5745: 149, 5765: 153, 5785: 157, 5805: 161, 5825: 165, 5855: 170, 5860: 172, 

28 5865: 173, 5870: 174, 5875: 175, 5880: 176, 5885: 177, 5890: 178, 5895: 179, 5900: 180, 5905: 181, 

29 5910: 182, 5915: 183, 5920: 184, 

30} 

31 

32 

33class Dot11ManagementCapabilities(): 

34 # 

35 # Capability Information 

36 # 0 1 2 3 4 5 6 7 8 9 A B C D E F 

37 # +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ 

38 # | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 

39 # +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ 

40 # | | | | | | | | | | | | | | | | 

41 # | | | | | | | | | | | | | | |---+-- Reserved 

42 # | | | | | | | | | | | | | | 

43 # | | | | | | | | | | | | | |---------- DSSS-OFDM 

44 # | | | | | | | | | | | | | 

45 # | | | | | | | | | | | |---+-------------- Reserved 

46 # | | | | | | | | | | | 

47 # | | | | | | | | | | |---------------------- Short slot time 

48 # | | | | | | | | | | 

49 # | | | | | | | | |---+-------------------------- Reserved 

50 # | | | | | | | | 

51 # | | | | | | | |---------------------------------- Channel agility (802.11b) 

52 # | | | | | | | 

53 # | | | | | | |-------------------------------------- PBCC (802.11b) 

54 # | | | | | | 

55 # | | | | | |------------------------------------------ Short preamble (802.11b) 

56 # | | | | | 

57 # | | | | |---------------------------------------------- Privacy 

58 # | | | | 

59 # | | | |-------------------------------------------------- CF-Poll request 

60 # | | | 

61 # | | |------------------------------------------------------ CF-Pollable 

62 # | | 

63 # | |---------------------------------------------------------- IBSS 

64 # | 

65 # |-------------------------------------------------------------- ESS 

66 # 

67 CAPABILITY_RESERVED_1 = int("1000000000000000", 2) 

68 CAPABILITY_RESERVED_2 = int("0100000000000000", 2) 

69 CAPABILITY_DSSS_OFDM = int("0010000000000000", 2) 

70 CAPABILITY_RESERVED_3 = int("0001000000000000", 2) 

71 CAPABILITY_RESERVED_4 = int("0000100000000000", 2) 

72 CAPABILITY_SHORT_SLOT_TIME = int("0000010000000000", 2) 

73 CAPABILITY_RESERVED_5 = int("0000001000000000", 2) 

74 CAPABILITY_RESERVED_6 = int("0000000100000000", 2) 

75 CAPABILITY_CH_AGILITY = int("0000000010000000", 2) 

76 CAPABILITY_PBCC = int("0000000001000000", 2) 

77 CAPABILITY_SHORT_PREAMBLE = int("0000000000100000", 2) 

78 CAPABILITY_PRIVACY = int("0000000000010000", 2) 

79 CAPABILITY_CF_POLL_REQ = int("0000000000001000", 2) 

80 CAPABILITY_CF_POLLABLE = int("0000000000000100", 2) 

81 CAPABILITY_IBSS = int("0000000000000010", 2) 

82 CAPABILITY_ESS = int("0000000000000001", 2) 

83 

84class Dot11Types(): 

85 # Management Types/SubTypes 

86 DOT11_TYPE_MANAGEMENT = int("00",2) 

87 DOT11_SUBTYPE_MANAGEMENT_ASSOCIATION_REQUEST = int("0000",2) 

88 DOT11_SUBTYPE_MANAGEMENT_ASSOCIATION_RESPONSE = int("0001",2) 

89 DOT11_SUBTYPE_MANAGEMENT_REASSOCIATION_REQUEST = int("0010",2) 

90 DOT11_SUBTYPE_MANAGEMENT_REASSOCIATION_RESPONSE = int("0011",2) 

91 DOT11_SUBTYPE_MANAGEMENT_PROBE_REQUEST = int("0100",2) 

92 DOT11_SUBTYPE_MANAGEMENT_PROBE_RESPONSE = int("0101",2) 

93 DOT11_SUBTYPE_MANAGEMENT_RESERVED1 = int("0110",2) 

94 DOT11_SUBTYPE_MANAGEMENT_RESERVED2 = int("0111",2) 

95 DOT11_SUBTYPE_MANAGEMENT_BEACON = int("1000",2) 

96 DOT11_SUBTYPE_MANAGEMENT_ATIM = int("1001",2) 

97 DOT11_SUBTYPE_MANAGEMENT_DISASSOCIATION = int("1010",2) 

98 DOT11_SUBTYPE_MANAGEMENT_AUTHENTICATION = int("1011",2) 

99 DOT11_SUBTYPE_MANAGEMENT_DEAUTHENTICATION = int("1100",2) 

100 DOT11_SUBTYPE_MANAGEMENT_ACTION = int("1101",2) 

101 DOT11_SUBTYPE_MANAGEMENT_RESERVED3 = int("1110",2) 

102 DOT11_SUBTYPE_MANAGEMENT_RESERVED4 = int("1111",2) 

103 

104 DOT11_TYPE_MANAGEMENT_SUBTYPE_ASSOCIATION_REQUEST = \ 

105 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_ASSOCIATION_REQUEST<<2 

106 DOT11_TYPE_MANAGEMENT_SUBTYPE_ASSOCIATION_RESPONSE = \ 

107 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_ASSOCIATION_RESPONSE<<2 

108 DOT11_TYPE_MANAGEMENT_SUBTYPE_REASSOCIATION_REQUEST = \ 

109 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_REASSOCIATION_REQUEST<<2 

110 DOT11_TYPE_MANAGEMENT_SUBTYPE_REASSOCIATION_RESPONSE = \ 

111 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_REASSOCIATION_RESPONSE<<2 

112 DOT11_TYPE_MANAGEMENT_SUBTYPE_PROBE_REQUEST = \ 

113 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_PROBE_REQUEST<<2 

114 DOT11_TYPE_MANAGEMENT_SUBTYPE_PROBE_RESPONSE = \ 

115 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_PROBE_RESPONSE<<2 

116 DOT11_TYPE_MANAGEMENT_SUBTYPE_RESERVED1 = \ 

117 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_RESERVED1<<2 

118 DOT11_TYPE_MANAGEMENT_SUBTYPE_RESERVED2 = \ 

119 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_RESERVED2<<2 

120 DOT11_TYPE_MANAGEMENT_SUBTYPE_BEACON = \ 

121 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_BEACON<<2 

122 DOT11_TYPE_MANAGEMENT_SUBTYPE_ATIM = \ 

123 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_ATIM<<2 

124 DOT11_TYPE_MANAGEMENT_SUBTYPE_DISASSOCIATION = \ 

125 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_DISASSOCIATION<<2 

126 DOT11_TYPE_MANAGEMENT_SUBTYPE_AUTHENTICATION = \ 

127 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_AUTHENTICATION<<2 

128 DOT11_TYPE_MANAGEMENT_SUBTYPE_DEAUTHENTICATION = \ 

129 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_DEAUTHENTICATION<<2 

130 DOT11_TYPE_MANAGEMENT_SUBTYPE_ACTION = \ 

131 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_ACTION<<2 

132 DOT11_TYPE_MANAGEMENT_SUBTYPE_RESERVED3 = \ 

133 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_RESERVED3<<2 

134 DOT11_TYPE_MANAGEMENT_SUBTYPE_RESERVED4 = \ 

135 DOT11_TYPE_MANAGEMENT|DOT11_SUBTYPE_MANAGEMENT_RESERVED4<<2 

136 

137 # Control Types/SubTypes 

138 DOT11_TYPE_CONTROL = int("01",2) 

139 DOT11_SUBTYPE_CONTROL_RESERVED1 = int("0000",2) 

140 DOT11_SUBTYPE_CONTROL_RESERVED2 = int("0001",2) 

141 DOT11_SUBTYPE_CONTROL_RESERVED3 = int("0010",2) 

142 DOT11_SUBTYPE_CONTROL_RESERVED4 = int("0011",2) 

143 DOT11_SUBTYPE_CONTROL_RESERVED5 = int("0100",2) 

144 DOT11_SUBTYPE_CONTROL_RESERVED6 = int("0101",2) 

145 DOT11_SUBTYPE_CONTROL_RESERVED7 = int("0110",2) 

146 DOT11_SUBTYPE_CONTROL_RESERVED8 = int("0111",2) 

147 DOT11_SUBTYPE_CONTROL_BLOCK_ACK_REQUEST = int("1000",2) 

148 DOT11_SUBTYPE_CONTROL_BLOCK_ACK = int("1001",2) 

149 DOT11_SUBTYPE_CONTROL_POWERSAVE_POLL = int("1010",2) 

150 DOT11_SUBTYPE_CONTROL_REQUEST_TO_SEND = int("1011",2) 

151 DOT11_SUBTYPE_CONTROL_CLEAR_TO_SEND = int("1100",2) 

152 DOT11_SUBTYPE_CONTROL_ACKNOWLEDGMENT = int("1101",2) 

153 DOT11_SUBTYPE_CONTROL_CF_END = int("1110",2) 

154 DOT11_SUBTYPE_CONTROL_CF_END_CF_ACK = int("1111",2) 

155 

156 DOT11_TYPE_CONTROL_SUBTYPE_RESERVED1 = \ 

157 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_RESERVED1<<2 

158 DOT11_TYPE_CONTROL_SUBTYPE_RESERVED2 = \ 

159 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_RESERVED2<<2 

160 DOT11_TYPE_CONTROL_SUBTYPE_RESERVED3 = \ 

161 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_RESERVED3<<2 

162 DOT11_TYPE_CONTROL_SUBTYPE_RESERVED4 = \ 

163 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_RESERVED4<<2 

164 DOT11_TYPE_CONTROL_SUBTYPE_RESERVED5 = \ 

165 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_RESERVED5<<2 

166 DOT11_TYPE_CONTROL_SUBTYPE_RESERVED6 = \ 

167 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_RESERVED6<<2 

168 DOT11_TYPE_CONTROL_SUBTYPE_RESERVED7 = \ 

169 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_RESERVED7<<2 

170 DOT11_TYPE_CONTROL_SUBTYPE_BLOCK_ACK_REQUEST = \ 

171 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_BLOCK_ACK_REQUEST<<2 

172 DOT11_TYPE_CONTROL_SUBTYPE_BLOCK_ACK = \ 

173 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_BLOCK_ACK<<2 

174 DOT11_TYPE_CONTROL_SUBTYPE_POWERSAVE_POLL = \ 

175 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_POWERSAVE_POLL<<2 

176 DOT11_TYPE_CONTROL_SUBTYPE_REQUEST_TO_SEND = \ 

177 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_REQUEST_TO_SEND<<2 

178 DOT11_TYPE_CONTROL_SUBTYPE_CLEAR_TO_SEND = \ 

179 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_CLEAR_TO_SEND<<2 

180 DOT11_TYPE_CONTROL_SUBTYPE_ACKNOWLEDGMENT = \ 

181 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_ACKNOWLEDGMENT<<2 

182 DOT11_TYPE_CONTROL_SUBTYPE_CF_END = \ 

183 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_CF_END<<2 

184 DOT11_TYPE_CONTROL_SUBTYPE_CF_END_CF_ACK = \ 

185 DOT11_TYPE_CONTROL|DOT11_SUBTYPE_CONTROL_CF_END_CF_ACK<<2 

186 

187 # Data Types/SubTypes 

188 DOT11_TYPE_DATA = int("10",2) 

189 DOT11_SUBTYPE_DATA = int("0000",2) 

190 DOT11_SUBTYPE_DATA_CF_ACK = int("0001",2) 

191 DOT11_SUBTYPE_DATA_CF_POLL = int("0010",2) 

192 DOT11_SUBTYPE_DATA_CF_ACK_CF_POLL = int("0011",2) 

193 DOT11_SUBTYPE_DATA_NULL_NO_DATA = int("0100",2) 

194 DOT11_SUBTYPE_DATA_CF_ACK_NO_DATA = int("0101",2) 

195 DOT11_SUBTYPE_DATA_CF_POLL_NO_DATA = int("0110",2) 

196 DOT11_SUBTYPE_DATA_CF_ACK_CF_POLL_NO_DATA = int("0111",2) 

197 DOT11_SUBTYPE_DATA_QOS_DATA = int("1000",2) 

198 DOT11_SUBTYPE_DATA_QOS_DATA_CF_ACK = int("1001",2) 

199 DOT11_SUBTYPE_DATA_QOS_DATA_CF_POLL = int("1010",2) 

200 DOT11_SUBTYPE_DATA_QOS_DATA_CF_ACK_CF_POLL = int("1011",2) 

201 DOT11_SUBTYPE_DATA_QOS_NULL_NO_DATA = int("1100",2) 

202 DOT11_SUBTYPE_DATA_RESERVED1 = int("1101",2) 

203 DOT11_SUBTYPE_DATA_QOS_CF_POLL_NO_DATA = int("1110",2) 

204 DOT11_SUBTYPE_DATA_QOS_CF_ACK_CF_POLL_NO_DATA = int("1111",2) 

205 

206 DOT11_TYPE_DATA_SUBTYPE_DATA = \ 

207 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA<<2 

208 DOT11_TYPE_DATA_SUBTYPE_CF_ACK = \ 

209 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_CF_ACK<<2 

210 DOT11_TYPE_DATA_SUBTYPE_CF_POLL = \ 

211 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_CF_POLL<<2 

212 DOT11_TYPE_DATA_SUBTYPE_CF_ACK_CF_POLL = \ 

213 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_CF_ACK_CF_POLL<<2 

214 DOT11_TYPE_DATA_SUBTYPE_NULL_NO_DATA = \ 

215 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_NULL_NO_DATA<<2 

216 DOT11_TYPE_DATA_SUBTYPE_CF_ACK_NO_DATA = \ 

217 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_CF_POLL_NO_DATA<<2 

218 DOT11_TYPE_DATA_SUBTYPE_CF_ACK_CF_POLL_NO_DATA = \ 

219 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_CF_ACK_CF_POLL_NO_DATA<<2 

220 DOT11_TYPE_DATA_SUBTYPE_QOS_DATA = \ 

221 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_QOS_DATA<<2 

222 DOT11_TYPE_DATA_SUBTYPE_QOS_DATA_CF_ACK = \ 

223 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_QOS_DATA_CF_ACK<<2 

224 DOT11_TYPE_DATA_SUBTYPE_QOS_DATA_CF_POLL = \ 

225 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_QOS_DATA_CF_POLL<<2 

226 DOT11_TYPE_DATA_SUBTYPE_QOS_DATA_CF_ACK_CF_POLL = \ 

227 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_QOS_DATA_CF_ACK_CF_POLL<<2 

228 DOT11_TYPE_DATA_SUBTYPE_QOS_NULL_NO_DATA = \ 

229 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_QOS_NULL_NO_DATA<<2 

230 DOT11_TYPE_DATA_SUBTYPE_RESERVED1 = \ 

231 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_RESERVED1<<2 

232 DOT11_TYPE_DATA_SUBTYPE_QOS_CF_POLL_NO_DATA = \ 

233 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_QOS_CF_POLL_NO_DATA<<2 

234 DOT11_TYPE_DATA_SUBTYPE_QOS_CF_ACK_CF_POLL_NO_DATA = \ 

235 DOT11_TYPE_DATA|DOT11_SUBTYPE_DATA_QOS_CF_ACK_CF_POLL_NO_DATA<<2 

236 

237 # Reserved Types/SubTypes 

238 DOT11_TYPE_RESERVED = int("11",2) 

239 DOT11_SUBTYPE_RESERVED_RESERVED1 = int("0000",2) 

240 DOT11_SUBTYPE_RESERVED_RESERVED2 = int("0001",2) 

241 DOT11_SUBTYPE_RESERVED_RESERVED3 = int("0010",2) 

242 DOT11_SUBTYPE_RESERVED_RESERVED4 = int("0011",2) 

243 DOT11_SUBTYPE_RESERVED_RESERVED5 = int("0100",2) 

244 DOT11_SUBTYPE_RESERVED_RESERVED6 = int("0101",2) 

245 DOT11_SUBTYPE_RESERVED_RESERVED7 = int("0110",2) 

246 DOT11_SUBTYPE_RESERVED_RESERVED8 = int("0111",2) 

247 DOT11_SUBTYPE_RESERVED_RESERVED9 = int("1000",2) 

248 DOT11_SUBTYPE_RESERVED_RESERVED10 = int("1001",2) 

249 DOT11_SUBTYPE_RESERVED_RESERVED11 = int("1010",2) 

250 DOT11_SUBTYPE_RESERVED_RESERVED12 = int("1011",2) 

251 DOT11_SUBTYPE_RESERVED_RESERVED13 = int("1100",2) 

252 DOT11_SUBTYPE_RESERVED_RESERVED14 = int("1101",2) 

253 DOT11_SUBTYPE_RESERVED_RESERVED15 = int("1110",2) 

254 DOT11_SUBTYPE_RESERVED_RESERVED16 = int("1111",2) 

255 

256 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED1 = \ 

257 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED1<<2 

258 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED2 = \ 

259 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED2<<2 

260 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED3 = \ 

261 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED3<<2 

262 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED4 = \ 

263 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED4<<2 

264 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED5 = \ 

265 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED5<<2 

266 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED6 = \ 

267 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED6<<2 

268 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED7 = \ 

269 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED7<<2 

270 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED8 = \ 

271 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED8<<2 

272 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED9 = \ 

273 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED9<<2 

274 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED10 = \ 

275 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED10<<2 

276 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED11 = \ 

277 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED11<<2 

278 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED12 = \ 

279 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED12<<2 

280 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED13 = \ 

281 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED13<<2 

282 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED14 = \ 

283 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED14<<2 

284 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED15 = \ 

285 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED15<<2 

286 DOT11_TYPE_RESERVED_SUBTYPE_RESERVED16 = \ 

287 DOT11_TYPE_RESERVED|DOT11_SUBTYPE_RESERVED_RESERVED16<<2 

288 

289class Dot11(ProtocolPacket): 

290 def __init__(self, aBuffer = None, FCS_at_end = True): 

291 header_size = 2 

292 self.__FCS_at_end=not not FCS_at_end # Is Boolean 

293 if self.__FCS_at_end: 

294 tail_size = 4 

295 else: 

296 tail_size = 0 

297 

298 ProtocolPacket.__init__(self, header_size,tail_size) 

299 if(aBuffer): 

300 self.load_packet(aBuffer) 

301 

302 def get_order(self): 

303 "Return 802.11 frame 'Order' field" 

304 b = self.header.get_byte(1) 

305 return ((b >> 7) & 0x01) 

306 

307 def set_order(self, value): 

308 "Set 802.11 frame 'Order' field" 

309 # clear the bits 

310 mask = (~0x80) & 0xFF 

311 masked = self.header.get_byte(1) & mask 

312 # set the bits 

313 nb = masked | ((value & 0x01) << 7) 

314 self.header.set_byte(1, nb) 

315 

316 def get_protectedFrame(self): 

317 "Return 802.11 frame 'Protected' field" 

318 b = self.header.get_byte(1) 

319 return ((b >> 6) & 0x01) 

320 

321 def set_protectedFrame(self, value): 

322 "Set 802.11 frame 'Protected Frame' field" 

323 # clear the bits 

324 mask = (~0x40) & 0xFF 

325 masked = self.header.get_byte(1) & mask 

326 # set the bits 

327 nb = masked | ((value & 0x01) << 6) 

328 self.header.set_byte(1, nb) 

329 

330 def get_moreData(self): 

331 "Return 802.11 frame 'More Data' field" 

332 b = self.header.get_byte(1) 

333 return ((b >> 5) & 0x01) 

334 

335 def set_moreData(self, value): 

336 "Set 802.11 frame 'More Data' field" 

337 # clear the bits 

338 mask = (~0x20) & 0xFF 

339 masked = self.header.get_byte(1) & mask 

340 # set the bits 

341 nb = masked | ((value & 0x01) << 5) 

342 self.header.set_byte(1, nb) 

343 

344 def get_powerManagement(self): 

345 "Return 802.11 frame 'Power Management' field" 

346 b = self.header.get_byte(1) 

347 return ((b >> 4) & 0x01) 

348 

349 def set_powerManagement(self, value): 

350 "Set 802.11 frame 'Power Management' field" 

351 # clear the bits 

352 mask = (~0x10) & 0xFF 

353 masked = self.header.get_byte(1) & mask 

354 # set the bits 

355 nb = masked | ((value & 0x01) << 4) 

356 self.header.set_byte(1, nb) 

357 

358 def get_retry(self): 

359 "Return 802.11 frame 'Retry' field" 

360 b = self.header.get_byte(1) 

361 return ((b >> 3) & 0x01) 

362 

363 def set_retry(self, value): 

364 "Set 802.11 frame 'Retry' field" 

365 # clear the bits 

366 mask = (~0x08) & 0xFF 

367 masked = self.header.get_byte(1) & mask 

368 # set the bits 

369 nb = masked | ((value & 0x01) << 3) 

370 self.header.set_byte(1, nb) 

371 

372 def get_moreFrag(self): 

373 "Return 802.11 frame 'More Fragments' field" 

374 b = self.header.get_byte(1) 

375 return ((b >> 2) & 0x01) 

376 

377 def set_moreFrag(self, value): 

378 "Set 802.11 frame 'More Fragments' field" 

379 # clear the bits 

380 mask = (~0x04) & 0xFF 

381 masked = self.header.get_byte(1) & mask 

382 # set the bits 

383 nb = masked | ((value & 0x01) << 2) 

384 self.header.set_byte(1, nb) 

385 

386 def get_fromDS(self): 

387 "Return 802.11 frame 'from DS' field" 

388 b = self.header.get_byte(1) 

389 return ((b >> 1) & 0x01) 

390 

391 def set_fromDS(self, value): 

392 "Set 802.11 frame 'from DS' field" 

393 # clear the bits 

394 mask = (~0x02) & 0xFF 

395 masked = self.header.get_byte(1) & mask 

396 # set the bits 

397 nb = masked | ((value & 0x01) << 1) 

398 self.header.set_byte(1, nb) 

399 

400 def get_toDS(self): 

401 "Return 802.11 frame 'to DS' field" 

402 b = self.header.get_byte(1) 

403 return (b & 0x01) 

404 

405 def set_toDS(self, value): 

406 "Set 802.11 frame 'to DS' field" 

407 # clear the bits 

408 mask = (~0x01) & 0xFF 

409 masked = self.header.get_byte(1) & mask 

410 # set the bits 

411 nb = masked | (value & 0x01) 

412 self.header.set_byte(1, nb) 

413 

414 def get_subtype(self): 

415 "Return 802.11 frame 'subtype' field" 

416 b = self.header.get_byte(0) 

417 return ((b >> 4) & 0x0F) 

418 

419 def set_subtype(self, value): 

420 "Set 802.11 frame 'subtype' field" 

421 # clear the bits 

422 mask = (~0xF0)&0xFF 

423 masked = self.header.get_byte(0) & mask 

424 # set the bits 

425 nb = masked | ((value << 4) & 0xF0) 

426 self.header.set_byte(0, nb) 

427 

428 def get_type(self): 

429 "Return 802.11 frame 'type' field" 

430 b = self.header.get_byte(0) 

431 return ((b >> 2) & 0x03) 

432 

433 def set_type(self, value): 

434 "Set 802.11 frame 'type' field" 

435 # clear the bits 

436 mask = (~0x0C)&0xFF 

437 masked = self.header.get_byte(0) & mask 

438 # set the bits 

439 nb = masked | ((value << 2) & 0x0C) 

440 self.header.set_byte(0, nb) 

441 

442 def get_type_n_subtype(self): 

443 "Return 802.11 frame 'Type and Subtype' field" 

444 b = self.header.get_byte(0) 

445 return ((b >> 2) & 0x3F) 

446 

447 def set_type_n_subtype(self, value): 

448 "Set 802.11 frame 'Type and Subtype' field" 

449 # clear the bits 

450 mask = (~0xFC)&0xFF 

451 masked = self.header.get_byte(0) & mask 

452 # set the bits 

453 nb = masked | ((value << 2) & 0xFC) 

454 self.header.set_byte(0, nb) 

455 

456 def get_version(self): 

457 "Return 802.11 frame control 'Protocol version' field" 

458 b = self.header.get_byte(0) 

459 return (b & 0x03) 

460 

461 def set_version(self, value): 

462 "Set the 802.11 frame control 'Protocol version' field" 

463 # clear the bits 

464 mask = (~0x03)&0xFF 

465 masked = self.header.get_byte(0) & mask 

466 # set the bits 

467 nb = masked | (value & 0x03) 

468 self.header.set_byte(0, nb) 

469 

470 def compute_checksum(self,bytes): 

471 crcle=crc32(bytes)&0xffffffff 

472 # ggrr this crc32 is in little endian, convert it to big endian  

473 crc=struct.pack('<L', crcle) 

474 # Convert to long 

475 (crc_long,) = struct.unpack('!L', crc) 

476 return crc_long 

477 

478 def is_QoS_frame(self): 

479 "Return 'True' if is an QoS data frame type" 

480 

481 b = self.header.get_byte(0) 

482 return (b & 0x80) and True 

483 

484 def is_no_framebody_frame(self): 

485 "Return 'True' if it frame contain no Frame Body" 

486 

487 b = self.header.get_byte(0) 

488 return (b & 0x40) and True 

489 

490 def is_cf_poll_frame(self): 

491 "Return 'True' if it frame is a CF_POLL frame" 

492 

493 b = self.header.get_byte(0) 

494 return (b & 0x20) and True 

495 

496 def is_cf_ack_frame(self): 

497 "Return 'True' if it frame is a CF_ACK frame" 

498 

499 b = self.header.get_byte(0) 

500 return (b & 0x10) and True 

501 

502 def get_fcs(self): 

503 "Return 802.11 'FCS' field" 

504 

505 if not self.__FCS_at_end: 

506 return None 

507 

508 b = self.tail.get_long(-4, ">") 

509 return b 

510 

511 def set_fcs(self, value = None): 

512 "Set the 802.11 CTS control frame 'FCS' field. If value is None, is auto_checksum" 

513 

514 if not self.__FCS_at_end: 

515 return 

516 

517 # calculate the FCS 

518 if value is None: 

519 payload = self.get_body_as_string() 

520 crc32=self.compute_checksum(payload) 

521 value=crc32 

522 

523 # set the bits 

524 nb = value & 0xFFFFFFFF 

525 self.tail.set_long(-4, nb) 

526 

527class Dot11ControlFrameCTS(ProtocolPacket): 

528 "802.11 Clear-To-Send Control Frame" 

529 

530 def __init__(self, aBuffer = None): 

531 header_size = 8 

532 tail_size = 0 

533 

534 ProtocolPacket.__init__(self, header_size, tail_size) 

535 if(aBuffer): 535 ↛ exitline 535 didn't return from function '__init__', because the condition on line 535 was never false

536 self.load_packet(aBuffer) 

537 

538 def get_duration(self): 

539 "Return 802.11 CTS control frame 'Duration' field" 

540 b = self.header.get_word(0, "<") 

541 return b 

542 

543 def set_duration(self, value): 

544 "Set the 802.11 CTS control frame 'Duration' field" 

545 # set the bits 

546 nb = value & 0xFFFF 

547 self.header.set_word(0, nb, "<") 

548 

549 def get_ra(self): 

550 "Return 802.11 CTS control frame 48 bit 'Receiver Address' field as a 6 bytes array" 

551 return self.header.get_bytes()[2:8] 

552 

553 def set_ra(self, value): 

554 "Set 802.11 CTS control frame 48 bit 'Receiver Address' field as a 6 bytes array" 

555 for i in range(0, 6): 

556 self.header.set_byte(2+i, value[i]) 

557 

558class Dot11ControlFrameACK(ProtocolPacket): 

559 "802.11 Acknowledgement Control Frame" 

560 

561 def __init__(self, aBuffer = None): 

562 header_size = 8 

563 tail_size = 0 

564 

565 ProtocolPacket.__init__(self, header_size, tail_size) 

566 if(aBuffer): 566 ↛ exitline 566 didn't return from function '__init__', because the condition on line 566 was never false

567 self.load_packet(aBuffer) 

568 

569 def get_duration(self): 

570 "Return 802.11 ACK control frame 'Duration' field" 

571 b = self.header.get_word(0, "<") 

572 return b 

573 

574 def set_duration(self, value): 

575 "Set the 802.11 ACK control frame 'Duration' field" 

576 # set the bits 

577 nb = value & 0xFFFF 

578 self.header.set_word(0, nb, "<") 

579 

580 def get_ra(self): 

581 "Return 802.11 ACK control frame 48 bit 'Receiver Address' field as a 6 bytes array" 

582 return self.header.get_bytes()[2:8] 

583 

584 def set_ra(self, value): 

585 "Set 802.11 ACK control frame 48 bit 'Receiver Address' field as a 6 bytes array" 

586 for i in range(0, 6): 

587 self.header.set_byte(2+i, value[i]) 

588 

589class Dot11ControlFrameRTS(ProtocolPacket): 

590 "802.11 Request-To-Send Control Frame" 

591 

592 def __init__(self, aBuffer = None): 

593 header_size = 14 

594 tail_size = 0 

595 

596 ProtocolPacket.__init__(self, header_size, tail_size) 

597 if(aBuffer): 597 ↛ exitline 597 didn't return from function '__init__', because the condition on line 597 was never false

598 self.load_packet(aBuffer) 

599 

600 def get_duration(self): 

601 "Return 802.11 RTS control frame 'Duration' field" 

602 b = self.header.get_word(0, "<") 

603 return b 

604 

605 def set_duration(self, value): 

606 "Set the 802.11 RTS control frame 'Duration' field" 

607 # set the bits 

608 nb = value & 0xFFFF 

609 self.header.set_word(0, nb, "<") 

610 

611 def get_ra(self): 

612 "Return 802.11 RTS control frame 48 bit 'Receiver Address' field as a 6 bytes array" 

613 return self.header.get_bytes()[2:8] 

614 

615 def set_ra(self, value): 

616 "Set 802.11 RTS control frame 48 bit 'Receiver Address' field as a 6 bytes array" 

617 for i in range(0, 6): 

618 self.header.set_byte(2+i, value[i]) 

619 

620 def get_ta(self): 

621 "Return 802.11 RTS control frame 48 bit 'Transmitter Address' field as a 6 bytes array" 

622 return self.header.get_bytes()[8:14] 

623 

624 def set_ta(self, value): 

625 "Set 802.11 RTS control frame 48 bit 'Transmitter Address' field as a 6 bytes array" 

626 for i in range(0, 6): 

627 self.header.set_byte(8+i, value[i]) 

628 

629class Dot11ControlFramePSPoll(ProtocolPacket): 

630 "802.11 Power-Save Poll Control Frame" 

631 

632 def __init__(self, aBuffer = None): 

633 header_size = 14 

634 tail_size = 0 

635 

636 ProtocolPacket.__init__(self, header_size, tail_size) 

637 if(aBuffer): 637 ↛ exitline 637 didn't return from function '__init__', because the condition on line 637 was never false

638 self.load_packet(aBuffer) 

639 

640 def get_aid(self): 

641 "Return 802.11 PSPoll control frame 'AID' field" 

642 # the spec says "The AID value always has its two MSBs each set to 1." 

643 # TODO: Should we do check/modify it? Wireshark shows the only MSB to 0 

644 b = self.header.get_word(0, "<") 

645 return b 

646 

647 def set_aid(self, value): 

648 "Set the 802.11 PSPoll control frame 'AID' field" 

649 # set the bits 

650 nb = value & 0xFFFF 

651 # the spec says "The AID value always has its two MSBs each set to 1." 

652 # TODO: Should we do check/modify it? Wireshark shows the only MSB to 0 

653 self.header.set_word(0, nb, "<") 

654 

655 def get_bssid(self): 

656 "Return 802.11 PSPoll control frame 48 bit 'BSS ID' field as a 6 bytes array" 

657 return self.header.get_bytes()[2:8] 

658 

659 def set_bssid(self, value): 

660 "Set 802.11 PSPoll control frame 48 bit 'BSS ID' field as a 6 bytes array" 

661 for i in range(0, 6): 

662 self.header.set_byte(2+i, value[i]) 

663 

664 def get_ta(self): 

665 "Return 802.11 PSPoll control frame 48 bit 'Transmitter Address' field as a 6 bytes array" 

666 return self.header.get_bytes()[8:14] 

667 

668 def set_ta(self, value): 

669 "Set 802.11 PSPoll control frame 48 bit 'Transmitter Address' field as a 6 bytes array" 

670 for i in range(0, 6): 

671 self.header.set_byte(8+i, value[i]) 

672 

673class Dot11ControlFrameCFEnd(ProtocolPacket): 

674 "802.11 'Contention Free End' Control Frame" 

675 

676 def __init__(self, aBuffer = None): 

677 header_size = 14 

678 tail_size = 0 

679 

680 ProtocolPacket.__init__(self, header_size, tail_size) 

681 if(aBuffer): 681 ↛ exitline 681 didn't return from function '__init__', because the condition on line 681 was never false

682 self.load_packet(aBuffer) 

683 

684 def get_duration(self): 

685 "Return 802.11 CF-End control frame 'Duration' field" 

686 b = self.header.get_word(0, "<") 

687 return b 

688 

689 def set_duration(self, value): 

690 "Set the 802.11 CF-End control frame 'Duration' field" 

691 # set the bits 

692 nb = value & 0xFFFF 

693 self.header.set_word(0, nb, "<") 

694 

695 def get_ra(self): 

696 "Return 802.11 CF-End control frame 48 bit 'Receiver Address' field as a 6 bytes array" 

697 return self.header.get_bytes()[2:8] 

698 

699 def set_ra(self, value): 

700 "Set 802.11 CF-End control frame 48 bit 'Receiver Address' field as a 6 bytes array" 

701 for i in range(0, 6): 

702 self.header.set_byte(2+i, value[i]) 

703 

704 def get_bssid(self): 

705 "Return 802.11 CF-End control frame 48 bit 'BSS ID' field as a 6 bytes array" 

706 return self.header.get_bytes()[8:14] 

707 

708 def set_bssid(self, value): 

709 "Set 802.11 CF-End control frame 48 bit 'BSS ID' field as a 6 bytes array" 

710 for i in range(0, 6): 

711 self.header.set_byte(8+i, value[i]) 

712 

713class Dot11ControlFrameCFEndCFACK(ProtocolPacket): 

714 '802.11 \'CF-End + CF-ACK\' Control Frame' 

715 

716 def __init__(self, aBuffer = None): 

717 header_size = 14 

718 tail_size = 0 

719 

720 ProtocolPacket.__init__(self, header_size, tail_size) 

721 if(aBuffer): 721 ↛ exitline 721 didn't return from function '__init__', because the condition on line 721 was never false

722 self.load_packet(aBuffer) 

723 

724 def get_duration(self): 

725 'Return 802.11 \'CF-End+CF-ACK\' control frame \'Duration\' field' 

726 b = self.header.get_word(0, "<") 

727 return b 

728 

729 def set_duration(self, value): 

730 'Set the 802.11 \'CF-End+CF-ACK\' control frame \'Duration\' field' 

731 # set the bits 

732 nb = value & 0xFFFF 

733 self.header.set_word(0, nb, "<") 

734 

735 def get_ra(self): 

736 'Return 802.11 \'CF-End+CF-ACK\' control frame 48 bit \'Receiver Address\' field as a 6 bytes array' 

737 return self.header.get_bytes()[2:8] 

738 

739 def set_ra(self, value): 

740 'Set 802.11 \'CF-End+CF-ACK\' control frame 48 bit \'Receiver Address\' field as a 6 bytes array' 

741 for i in range(0, 6): 

742 self.header.set_byte(2+i, value[i]) 

743 

744 def get_bssid(self): 

745 'Return 802.11 \'CF-End+CF-ACK\' control frame 48 bit \'BSS ID\' field as a 6 bytes array' 

746 return self.header.get_bytes()[8:16] 

747 

748 def set_bssid(self, value): 

749 'Set 802.11 \'CF-End+CF-ACK\' control frame 48 bit \'BSS ID\' field as a 6 bytes array' 

750 for i in range(0, 6): 

751 self.header.set_byte(8+i, value[i]) 

752 

753class Dot11DataFrame(ProtocolPacket): 

754 '802.11 Data Frame' 

755 

756 def __init__(self, aBuffer = None): 

757 header_size = 22 

758 tail_size = 0 

759 

760 ProtocolPacket.__init__(self, header_size, tail_size) 

761 if(aBuffer): 

762 self.load_packet(aBuffer) 

763 

764 def get_duration(self): 

765 'Return 802.11 \'Data\' data frame \'Duration\' field' 

766 b = self.header.get_word(0, "<") 

767 return b 

768 

769 def set_duration(self, value): 

770 'Set the 802.11 \'Data\' data frame \'Duration\' field' 

771 # set the bits 

772 nb = value & 0xFFFF 

773 self.header.set_word(0, nb, "<") 

774 

775 def get_address1(self): 

776 'Return 802.11 \'Data\' data frame 48 bit \'Address1\' field as a 6 bytes array' 

777 return self.header.get_bytes()[2:8] 

778 

779 def set_address1(self, value): 

780 'Set 802.11 \'Data\' data frame 48 bit \'Address1\' field as a 6 bytes array' 

781 for i in range(0, 6): 

782 self.header.set_byte(2+i, value[i]) 

783 

784 def get_address2(self): 

785 'Return 802.11 \'Data\' data frame 48 bit \'Address2\' field as a 6 bytes array' 

786 return self.header.get_bytes()[8:14] 

787 

788 def set_address2(self, value): 

789 'Set 802.11 \'Data\' data frame 48 bit \'Address2\' field as a 6 bytes array' 

790 for i in range(0, 6): 

791 self.header.set_byte(8+i, value[i]) 

792 

793 def get_address3(self): 

794 'Return 802.11 \'Data\' data frame 48 bit \'Address3\' field as a 6 bytes array' 

795 return self.header.get_bytes()[14: 20] 

796 

797 def set_address3(self, value): 

798 'Set 802.11 \'Data\' data frame 48 bit \'Address3\' field as a 6 bytes array' 

799 for i in range(0, 6): 

800 self.header.set_byte(14+i, value[i]) 

801 

802 def get_sequence_control(self): 

803 'Return 802.11 \'Data\' data frame \'Sequence Control\' field' 

804 b = self.header.get_word(20, "<") 

805 return b 

806 

807 def set_sequence_control(self, value): 

808 'Set the 802.11 \'Data\' data frame \'Sequence Control\' field' 

809 # set the bits 

810 nb = value & 0xFFFF 

811 self.header.set_word(20, nb, "<") 

812 

813 def get_fragment_number(self): 

814 'Return 802.11 \'Data\' data frame \'Fragment Number\' subfield' 

815 

816 b = self.header.get_word(20, "<") 

817 return (b&0x000F) 

818 

819 def set_fragment_number(self, value): 

820 'Set the 802.11 \'Data\' data frame \'Fragment Number\' subfield' 

821 # clear the bits 

822 mask = (~0x000F) & 0xFFFF 

823 masked = self.header.get_word(20, "<") & mask 

824 # set the bits  

825 nb = masked | (value & 0x000F) 

826 self.header.set_word(20, nb, "<") 

827 

828 def get_sequence_number(self): 

829 'Return 802.11 \'Data\' data frame \'Sequence Number\' subfield' 

830 

831 b = self.header.get_word(20, "<") 

832 return ((b>>4) & 0xFFF) 

833 

834 def set_sequence_number(self, value): 

835 'Set the 802.11 \'Data\' data frame \'Sequence Number\' subfield' 

836 # clear the bits 

837 mask = (~0xFFF0) & 0xFFFF 

838 masked = self.header.get_word(20, "<") & mask 

839 # set the bits  

840 nb = masked | ((value & 0x0FFF ) << 4 ) 

841 self.header.set_word(20, nb, "<") 

842 

843 def get_frame_body(self): 

844 'Return 802.11 \'Data\' data frame \'Frame Body\' field' 

845 

846 return self.get_body_as_string() 

847 

848 def set_frame_body(self, data): 

849 'Set 802.11 \'Data\' data frame \'Frame Body\' field' 

850 

851 self.load_body(data) 

852 

853class Dot11DataQoSFrame(Dot11DataFrame): 

854 '802.11 Data QoS Frame' 

855 

856 def __init__(self, aBuffer = None): 

857 header_size = 24 

858 tail_size = 0 

859 

860 ProtocolPacket.__init__(self, header_size, tail_size) 

861 if(aBuffer): 

862 self.load_packet(aBuffer) 

863 

864 def get_QoS(self): 

865 'Return 802.11 \'Data\' data frame \'QoS\' field' 

866 b = self.header.get_word(22, "<") 

867 return b 

868 

869 def set_QoS(self, value): 

870 'Set the 802.11 \'Data\' data frame \'QoS\' field' 

871 # set the bits 

872 nb = value & 0xFFFF 

873 self.header.set_word(22, nb, "<") 

874 

875class Dot11DataAddr4Frame(Dot11DataFrame): 

876 '802.11 Data With ToDS From DS Flags (With Addr 4) Frame' 

877 

878 def __init__(self, aBuffer = None): 

879 header_size = 28 

880 tail_size = 0 

881 

882 ProtocolPacket.__init__(self, header_size, tail_size) 

883 if(aBuffer): 

884 self.load_packet(aBuffer) 

885 

886 def get_address4(self): 

887 'Return 802.11 \'Data\' data frame 48 bit \'Address4\' field as a 6 bytes array' 

888 return self.header.get_bytes()[22:28] 

889 

890 def set_address4(self, value): 

891 'Set 802.11 \'Data\' data frame 48 bit \'Address4\' field as a 6 bytes array' 

892 for i in range(0, 6): 

893 self.header.set_byte(22+i, value[i]) 

894 

895class Dot11DataAddr4QoSFrame(Dot11DataAddr4Frame): 

896 '802.11 Data With ToDS From DS Flags (With Addr 4) and QoS Frame' 

897 

898 def __init__(self, aBuffer = None): 

899 header_size = 30 

900 tail_size = 0 

901 

902 ProtocolPacket.__init__(self, header_size, tail_size) 

903 if(aBuffer): 

904 self.load_packet(aBuffer) 

905 

906 def get_QoS(self): 

907 'Return 802.11 \'Data\' data frame \'QoS\' field' 

908 b = self.header.get_word(28, "<") 

909 return b 

910 

911 def set_QoS(self, value): 

912 'Set the 802.11 \'Data\' data frame \'QoS\' field' 

913 # set the bits 

914 nb = value & 0xFFFF 

915 self.header.set_word(28, nb, "<") 

916 

917class SAPTypes(): 

918 NULL = 0x00 

919 LLC_SLMGMT = 0x02 

920 SNA_PATHCTRL = 0x04 

921 IP = 0x06 

922 SNA1 = 0x08 

923 SNA2 = 0x0C 

924 PROWAY_NM_INIT = 0x0E 

925 NETWARE1 = 0x10 

926 OSINL1 = 0x14 

927 TI = 0x18 

928 OSINL2 = 0x20 

929 OSINL3 = 0x34 

930 SNA3 = 0x40 

931 BPDU = 0x42 

932 RS511 = 0x4E 

933 OSINL4 = 0x54 

934 X25 = 0x7E 

935 XNS = 0x80 

936 BACNET = 0x82 

937 NESTAR = 0x86 

938 PROWAY_ASLM = 0x8E 

939 ARP = 0x98 

940 SNAP = 0xAA 

941 HPJD = 0xB4 

942 VINES1 = 0xBA 

943 VINES2 = 0xBC 

944 NETWARE2 = 0xE0 

945 NETBIOS = 0xF0 

946 IBMNM = 0xF4 

947 HPEXT = 0xF8 

948 UB = 0xFA 

949 RPL = 0xFC 

950 OSINL5 = 0xFE 

951 GLOBAL = 0xFF 

952 

953class LLC(ProtocolPacket): 

954 '802.2 Logical Link Control (LLC) Frame' 

955 

956 DLC_UNNUMBERED_FRAMES = 0x03 

957 

958 def __init__(self, aBuffer = None): 

959 header_size = 3 

960 tail_size = 0 

961 

962 ProtocolPacket.__init__(self, header_size, tail_size) 

963 if(aBuffer): 

964 self.load_packet(aBuffer) 

965 

966 def get_DSAP(self): 

967 "Get the Destination Service Access Point (SAP) from LLC frame" 

968 return self.header.get_byte(0) 

969 

970 def set_DSAP(self, value): 

971 "Set the Destination Service Access Point (SAP) of LLC frame" 

972 self.header.set_byte(0, value) 

973 

974 def get_SSAP(self): 

975 "Get the Source Service Access Point (SAP) from LLC frame" 

976 return self.header.get_byte(1) 

977 

978 def set_SSAP(self, value): 

979 "Set the Source Service Access Point (SAP) of LLC frame" 

980 self.header.set_byte(1, value) 

981 

982 def get_control(self): 

983 "Get the Control field from LLC frame" 

984 return self.header.get_byte(2) 

985 

986 def set_control(self, value): 

987 "Set the Control field of LLC frame" 

988 self.header.set_byte(2, value) 

989 

990class SNAP(ProtocolPacket): 

991 '802.2 SubNetwork Access Protocol (SNAP) Frame' 

992 

993 def __init__(self, aBuffer = None): 

994 header_size = 5 

995 tail_size = 0 

996 

997 ProtocolPacket.__init__(self, header_size, tail_size) 

998 if(aBuffer): 

999 self.load_packet(aBuffer) 

1000 

1001 def get_OUI(self): 

1002 "Get the three-octet Organizationally Unique Identifier (OUI) SNAP frame" 

1003 b = array_tobytes(self.header.get_bytes()[0:3]) 

1004 #unpack requires a string argument of length 4 and b is 3 bytes long 

1005 (oui,) = struct.unpack('!L', b'\x00'+b) 

1006 return oui 

1007 

1008 def set_OUI(self, value): 

1009 "Set the three-octet Organizationally Unique Identifier (OUI) SNAP frame" 

1010 # clear the bits 

1011 mask = ((~0xFFFFFF00) & 0xFF) 

1012 masked = self.header.get_long(0, ">") & mask 

1013 # set the bits  

1014 nb = masked | ((value & 0x00FFFFFF) << 8) 

1015 self.header.set_long(0, nb) 

1016 

1017 def get_protoID(self): 

1018 "Get the two-octet Protocol Identifier (PID) SNAP field" 

1019 return self.header.get_word(3, ">") 

1020 

1021 def set_protoID(self, value): 

1022 "Set the two-octet Protocol Identifier (PID) SNAP field" 

1023 self.header.set_word(3, value, ">") 

1024 

1025class Dot11WEP(ProtocolPacket): 

1026 '802.11 WEP' 

1027 

1028 def __init__(self, aBuffer = None): 

1029 header_size = 4 

1030 tail_size = 0 

1031 

1032 ProtocolPacket.__init__(self, header_size, tail_size) 

1033 if(aBuffer): 

1034 self.load_packet(aBuffer) 

1035 

1036 def is_WEP(self): 

1037 'Return True if it\'s a WEP' 

1038 # We already know that it's private. 

1039 # Now we must differentiate between WEP and WPA/WPA2 

1040 # WPA/WPA2 have the ExtIV (Bit 5) enaled and WEP disabled 

1041 b = self.header.get_byte(3) 

1042 return not (b & 0x20) 

1043 

1044 def get_iv(self): 

1045 'Return the \'WEP IV\' field' 

1046 b = array_tobytes(self.header.get_bytes()[0:3]) 

1047 #unpack requires a string argument of length 4 and b is 3 bytes long 

1048 (iv,) = struct.unpack('!L', b'\x00'+b) 

1049 return iv 

1050 

1051 def set_iv(self, value): 

1052 'Set the \'WEP IV\' field.' 

1053 # clear the bits 

1054 mask = ((~0xFFFFFF00) & 0xFF) 

1055 masked = self.header.get_long(0, ">") & mask 

1056 # set the bits  

1057 nb = masked | ((value & 0x00FFFFFF) << 8) 

1058 self.header.set_long(0, nb) 

1059 

1060 def get_keyid(self): 

1061 'Return the \'WEP KEY ID\' field' 

1062 b = self.header.get_byte(3) 

1063 return ((b>>6) & 0x03) 

1064 

1065 def set_keyid(self, value): 

1066 'Set the \'WEP KEY ID\' field' 

1067 # clear the bits 

1068 mask = (~0xC0) & 0xFF 

1069 masked = self.header.get_byte(3) & mask 

1070 # set the bits 

1071 nb = masked | ((value & 0x03) << 6) 

1072 self.header.set_byte(3, nb) 

1073 

1074 def get_decrypted_data(self, key_string): 

1075 'Return \'WEP Data\' field decrypted' 

1076 

1077 # Needs to be at least 8 bytes of payload  

1078 if len(self.body_string)<8: 1078 ↛ 1079line 1078 didn't jump to line 1079, because the condition on line 1078 was never true

1079 return self.body_string 

1080 

1081 # initialize the first bytes of the key from the IV  

1082 # and copy rest of the WEP key (the secret part)  

1083 

1084 # Convert IV to 3 bytes long string 

1085 iv=struct.pack('>L',self.get_iv())[-3:] 

1086 key=iv+key_string 

1087 rc4=RC4(key) 

1088 decrypted_data=rc4.decrypt(self.body_string) 

1089 

1090 return decrypted_data 

1091 

1092 def get_encrypted_data(self, key_string): 

1093 # RC4 is symmetric 

1094 return self.get_decrypted_data(key_string) 

1095 

1096 def encrypt_frame(self, key_string): 

1097 enc = self.get_encrypted_data(key_string) 

1098 self.load_body(enc) 

1099 

1100class Dot11WEPData(ProtocolPacket): 

1101 '802.11 WEP Data Part' 

1102 

1103 def __init__(self, aBuffer = None): 

1104 header_size = 0 

1105 tail_size = 4 

1106 

1107 ProtocolPacket.__init__(self, header_size, tail_size) 

1108 if(aBuffer): 

1109 self.load_packet(aBuffer) 

1110 

1111 def get_icv(self): 

1112 "Return 'WEP ICV' field" 

1113 

1114 b = self.tail.get_long(-4, ">") 

1115 return b 

1116 

1117 def set_icv(self, value = None): 

1118 "Set 'WEP ICV' field" 

1119 

1120 # Compute the WEP ICV 

1121 if value is None: 1121 ↛ 1122line 1121 didn't jump to line 1122, because the condition on line 1121 was never true

1122 value=self.get_computed_icv() 

1123 

1124 # set the bits 

1125 nb = value & 0xFFFFFFFF 

1126 self.tail.set_long(-4, nb) 

1127 

1128 def get_computed_icv(self): 

1129 crcle=crc32(self.body_string)&0xffffffff 

1130 # This crc32 is in little endian, convert it to big endian  

1131 crc=struct.pack('<L', crcle) 

1132 # Convert to long 

1133 (crc_long,) = struct.unpack('!L', crc) 

1134 return crc_long 

1135 

1136 def check_icv(self): 

1137 computed_icv=self.get_computed_icv() 

1138 current_icv=self.get_icv() 

1139 if computed_icv==current_icv: 1139 ↛ 1142line 1139 didn't jump to line 1142, because the condition on line 1139 was never false

1140 return True 

1141 else: 

1142 return False 

1143 

1144class Dot11WPA(ProtocolPacket): 

1145 '802.11 WPA' 

1146 

1147 def __init__(self, aBuffer = None): 

1148 header_size = 8 

1149 tail_size = 0 

1150 

1151 ProtocolPacket.__init__(self, header_size, tail_size) 

1152 if(aBuffer): 1152 ↛ exitline 1152 didn't return from function '__init__', because the condition on line 1152 was never false

1153 self.load_packet(aBuffer) 

1154 

1155 def is_WPA(self): 

1156 'Return True if it\'s a WPA' 

1157 # Now we must differentiate between WPA and WPA2 

1158 # In WPA WEPSeed is set to (TSC1 | 0x20) & 0x7f. 

1159 b = self.get_WEPSeed() == ((self.get_TSC1() | 0x20 ) & 0x7f) 

1160 return (b and self.get_extIV()) 

1161 

1162 def get_keyid(self): 

1163 'Return the \'WPA KEY ID\' field' 

1164 b = self.header.get_byte(3) 

1165 return ((b>>6) & 0x03) 

1166 

1167 def set_keyid(self, value): 

1168 'Set the \'WPA KEY ID\' field' 

1169 # clear the bits 

1170 mask = (~0xC0) & 0xFF 

1171 masked = self.header.get_byte(3) & mask 

1172 # set the bits 

1173 nb = masked | ((value & 0x03) << 6) 

1174 self.header.set_byte(3, nb) 

1175 

1176 def get_decrypted_data(self): 

1177 'Return \'WPA Data\' field decrypted' 

1178 # TODO: Replace it with the decoded string 

1179 return self.body_string 

1180 

1181 def get_TSC1(self): 

1182 'Return the \'WPA TSC1\' field' 

1183 b = self.header.get_byte(0) 

1184 return (b & 0xFF) 

1185 

1186 def set_TSC1(self, value): 

1187 'Set the \'WPA TSC1\' field' 

1188 # set the bits 

1189 nb = (value & 0xFF) 

1190 self.header.set_byte(0, nb) 

1191 

1192 def get_WEPSeed(self): 

1193 'Return the \'WPA WEPSeed\' field' 

1194 b = self.header.get_byte(1) 

1195 return (b & 0xFF) 

1196 

1197 def set_WEPSeed(self, value): 

1198 'Set the \'WPA WEPSeed\' field' 

1199 # set the bits 

1200 nb = (value & 0xFF) 

1201 self.header.set_byte(1, nb) 

1202 

1203 def get_TSC0(self): 

1204 'Return the \'WPA TSC0\' field' 

1205 b = self.header.get_byte(2) 

1206 return (b & 0xFF) 

1207 

1208 def set_TSC0(self, value): 

1209 'Set the \'WPA TSC0\' field' 

1210 # set the bits 

1211 nb = (value & 0xFF) 

1212 self.header.set_byte(2, nb) 

1213 

1214 def get_extIV(self): 

1215 'Return the \'WPA extID\' field' 

1216 b = self.header.get_byte(3) 

1217 return ((b>>5) & 0x1) 

1218 

1219 def set_extIV(self, value): 

1220 'Set the \'WPA extID\' field' 

1221 # clear the bits 

1222 mask = (~0x20) & 0xFF 

1223 masked = self.header.get_byte(3) & mask 

1224 # set the bits 

1225 nb = masked | ((value & 0x01) << 5) 

1226 self.header.set_byte(3, nb) 

1227 

1228 def get_TSC2(self): 

1229 'Return the \'WPA TSC2\' field' 

1230 b = self.header.get_byte(4) 

1231 return (b & 0xFF) 

1232 

1233 def set_TSC2(self, value): 

1234 'Set the \'WPA TSC2\' field' 

1235 # set the bits 

1236 nb = (value & 0xFF) 

1237 self.header.set_byte(4, nb) 

1238 

1239 def get_TSC3(self): 

1240 'Return the \'WPA TSC3\' field' 

1241 b = self.header.get_byte(5) 

1242 return (b & 0xFF) 

1243 

1244 def set_TSC3(self, value): 

1245 'Set the \'WPA TSC3\' field' 

1246 # set the bits 

1247 nb = (value & 0xFF) 

1248 self.header.set_byte(5, nb) 

1249 

1250 def get_TSC4(self): 

1251 'Return the \'WPA TSC4\' field' 

1252 b = self.header.get_byte(6) 

1253 return (b & 0xFF) 

1254 

1255 def set_TSC4(self, value): 

1256 'Set the \'WPA TSC4\' field' 

1257 # set the bits 

1258 nb = (value & 0xFF) 

1259 self.header.set_byte(6, nb) 

1260 

1261 def get_TSC5(self): 

1262 'Return the \'WPA TSC5\' field' 

1263 b = self.header.get_byte(7) 

1264 return (b & 0xFF) 

1265 

1266 def set_TSC5(self, value): 

1267 'Set the \'WPA TSC5\' field' 

1268 # set the bits 

1269 nb = (value & 0xFF) 

1270 self.header.set_byte(7, nb) 

1271 

1272class Dot11WPAData(ProtocolPacket): 

1273 '802.11 WPA Data Part' 

1274 

1275 def __init__(self, aBuffer = None): 

1276 header_size = 0 

1277 tail_size = 12 

1278 

1279 ProtocolPacket.__init__(self, header_size, tail_size) 

1280 if(aBuffer): 1280 ↛ exitline 1280 didn't return from function '__init__', because the condition on line 1280 was never false

1281 self.load_packet(aBuffer) 

1282 

1283 def get_icv(self): 

1284 "Return 'WPA ICV' field" 

1285 

1286 b = self.tail.get_long(-4, ">") 

1287 return b 

1288 

1289 def set_icv(self, value = None): 

1290 "Set 'WPA ICV' field" 

1291 

1292 # calculate the FCS 

1293 if value is None: 

1294 value=self.compute_checksum(self.body_string) 

1295 

1296 # set the bits 

1297 nb = value & 0xFFFFFFFF 

1298 self.tail.set_long(-4, nb) 

1299 

1300 def get_MIC(self): 

1301 'Return the \'WPA2Data MIC\' field' 

1302 return self.get_tail_as_string()[:8] 

1303 

1304 def set_MIC(self, value): 

1305 'Set the \'WPA2Data MIC\' field' 

1306 #Padding to 8 bytes with 0x00's  

1307 value.ljust(8,b'\x00') 

1308 #Stripping to 8 bytes 

1309 value=value[:8] 

1310 icv=self.tail.get_buffer_as_string()[-4:] 

1311 self.tail.set_bytes_from_string(value+icv) 

1312 

1313class Dot11WPA2(ProtocolPacket): 

1314 '802.11 WPA2' 

1315 

1316 def __init__(self, aBuffer = None): 

1317 header_size = 8 

1318 tail_size = 0 

1319 

1320 ProtocolPacket.__init__(self, header_size, tail_size) 

1321 if(aBuffer): 1321 ↛ exitline 1321 didn't return from function '__init__', because the condition on line 1321 was never false

1322 self.load_packet(aBuffer) 

1323 

1324 def is_WPA2(self): 

1325 'Return True if it\'s a WPA2' 

1326 # Now we must differentiate between WPA and WPA2 

1327 # In WPA WEPSeed is set to (TSC1 | 0x20) & 0x7f. 

1328 # In WPA2 WEPSeed=PN1 and TSC1=PN0 

1329 b = self.get_PN1() == ((self.get_PN0() | 0x20 ) & 0x7f) 

1330 return (not b and self.get_extIV()) 

1331 

1332 def get_extIV(self): 

1333 'Return the \'WPA2 extID\' field' 

1334 b = self.header.get_byte(3) 

1335 return ((b>>5) & 0x1) 

1336 

1337 def set_extIV(self, value): 

1338 'Set the \'WPA2 extID\' field' 

1339 # clear the bits 

1340 mask = (~0x20) & 0xFF 

1341 masked = self.header.get_byte(3) & mask 

1342 # set the bits 

1343 nb = masked | ((value & 0x01) << 5) 

1344 self.header.set_byte(3, nb) 

1345 

1346 def get_keyid(self): 

1347 'Return the \'WPA2 KEY ID\' field' 

1348 b = self.header.get_byte(3) 

1349 return ((b>>6) & 0x03) 

1350 

1351 def set_keyid(self, value): 

1352 'Set the \'WPA2 KEY ID\' field' 

1353 # clear the bits 

1354 mask = (~0xC0) & 0xFF 

1355 masked = self.header.get_byte(3) & mask 

1356 # set the bits 

1357 nb = masked | ((value & 0x03) << 6) 

1358 self.header.set_byte(3, nb) 

1359 

1360 def get_decrypted_data(self): 

1361 'Return \'WPA2 Data\' field decrypted' 

1362 # TODO: Replace it with the decoded string 

1363 return self.body_string 

1364 

1365 def get_PN0(self): 

1366 'Return the \'WPA2 PN0\' field' 

1367 b = self.header.get_byte(0) 

1368 return (b & 0xFF) 

1369 

1370 def set_PN0(self, value): 

1371 'Set the \'WPA2 PN0\' field' 

1372 # set the bits 

1373 nb = (value & 0xFF) 

1374 self.header.set_byte(0, nb) 

1375 

1376 def get_PN1(self): 

1377 'Return the \'WPA2 PN1\' field' 

1378 b = self.header.get_byte(1) 

1379 return (b & 0xFF) 

1380 

1381 def set_PN1(self, value): 

1382 'Set the \'WPA2 PN1\' field' 

1383 # set the bits 

1384 nb = (value & 0xFF) 

1385 self.header.set_byte(1, nb) 

1386 

1387 def get_PN2(self): 

1388 'Return the \'WPA2 PN2\' field' 

1389 b = self.header.get_byte(4) 

1390 return (b & 0xFF) 

1391 

1392 def set_PN2(self, value): 

1393 'Set the \'WPA2 PN2\' field' 

1394 # set the bits 

1395 nb = (value & 0xFF) 

1396 self.header.set_byte(4, nb) 

1397 

1398 def get_PN3(self): 

1399 'Return the \'WPA2 PN3\' field' 

1400 b = self.header.get_byte(5) 

1401 return (b & 0xFF) 

1402 

1403 def set_PN3(self, value): 

1404 'Set the \'WPA2 PN3\' field' 

1405 # set the bits 

1406 nb = (value & 0xFF) 

1407 self.header.set_byte(5, nb) 

1408 

1409 def get_PN4(self): 

1410 'Return the \'WPA2 PN4\' field' 

1411 b = self.header.get_byte(6) 

1412 return (b & 0xFF) 

1413 

1414 def set_PN4(self, value): 

1415 'Set the \'WPA2 PN4\' field' 

1416 # set the bits 

1417 nb = (value & 0xFF) 

1418 self.header.set_byte(6, nb) 

1419 

1420 def get_PN5(self): 

1421 'Return the \'WPA2 PN5\' field' 

1422 b = self.header.get_byte(7) 

1423 return (b & 0xFF) 

1424 

1425 def set_PN5(self, value): 

1426 'Set the \'WPA2 PN5\' field' 

1427 # set the bits 

1428 nb = (value & 0xFF) 

1429 self.header.set_byte(7, nb) 

1430 

1431class Dot11WPA2Data(ProtocolPacket): 

1432 '802.11 WPA2 Data Part' 

1433 

1434 def __init__(self, aBuffer = None): 

1435 header_size = 0 

1436 tail_size = 8 

1437 

1438 ProtocolPacket.__init__(self, header_size, tail_size) 

1439 if(aBuffer): 1439 ↛ exitline 1439 didn't return from function '__init__', because the condition on line 1439 was never false

1440 self.load_packet(aBuffer) 

1441 

1442 def get_MIC(self): 

1443 'Return the \'WPA2Data MIC\' field' 

1444 return self.get_tail_as_string() 

1445 

1446 def set_MIC(self, value): 

1447 'Set the \'WPA2Data MIC\' field' 

1448 #Padding to 8 bytes with 0x00's  

1449 value.ljust(8,b'\x00') 

1450 #Stripping to 8 bytes 

1451 value=value[:8] 

1452 self.tail.set_bytes_from_string(value) 

1453 

1454class RadioTap(ProtocolPacket): 

1455 __HEADER_BASE_SIZE = 8 # minimal header size 

1456 _PRESENT_FLAGS_SIZE = 4 

1457 _BASE_PRESENT_FLAGS_OFFSET = 4 

1458 

1459 class __RadioTapField(object): 

1460 ALIGNMENT = 1 

1461 

1462 def __str__( self ): 

1463 return str( self.__class__.__name__ ) 

1464 

1465 class RTF_TSFT(__RadioTapField): 

1466 BIT_NUMBER = 0 

1467 STRUCTURE = "<Q" 

1468 ALIGNMENT = 8 

1469 

1470 class RTF_FLAGS(__RadioTapField): 

1471 BIT_NUMBER = 1 

1472 STRUCTURE = "<B" 

1473 

1474 # https://web.archive.org/web/20160423125307/www.radiotap.org/defined-fields/Flags 

1475 PROPERTY_CFP = 0x01 #sent/received during CFP 

1476 PROPERTY_SHORTPREAMBLE = 0x02 #sent/received with short preamble 

1477 PROPERTY_WEP = 0x04 #sent/received with WEP encryption 

1478 PROPERTY_FRAGMENTATION = 0x08 #sent/received with fragmentation 

1479 PROPERTY_FCS_AT_END = 0x10 #frame includes FCS 

1480 PROPERTY_PAYLOAD_PADDING= 0x20 #frame has padding between 802.11 header and payload (to 32-bit boundary) 

1481 PROPERTY_BAD_FCS = 0x40 #does not pass FCS check 

1482 PROPERTY_SHORT_GI = 0x80 #frame used short guard interval (HT). Unspecified but used: 

1483 

1484 class RTF_RATE(__RadioTapField): 

1485 BIT_NUMBER = 2 

1486 STRUCTURE = "<B" 

1487 

1488 class RTF_CHANNEL(__RadioTapField): 

1489 BIT_NUMBER = 3 

1490 STRUCTURE = "<HH" 

1491 ALIGNMENT = 2 

1492 

1493 class RTF_FHSS(__RadioTapField): 

1494 BIT_NUMBER = 4 

1495 STRUCTURE = "<BB" 

1496 

1497 class RTF_DBM_ANTSIGNAL(__RadioTapField): 

1498 BIT_NUMBER = 5 

1499 STRUCTURE = "<B" 

1500 

1501 class RTF_DBM_ANTNOISE(__RadioTapField): 

1502 BIT_NUMBER = 6 

1503 STRUCTURE = "<B" 

1504 

1505 class RTF_LOCK_QUALITY(__RadioTapField): 

1506 BIT_NUMBER = 7 

1507 STRUCTURE = "<H" 

1508 ALIGNMENT = 2 

1509 

1510 class RTF_TX_ATTENUATION(__RadioTapField): 

1511 BIT_NUMBER = 8 

1512 STRUCTURE = "<H" 

1513 ALIGNMENT = 2 

1514 

1515 class RTF_DB_TX_ATTENUATION(__RadioTapField): 

1516 BIT_NUMBER = 9 

1517 STRUCTURE = "<H" 

1518 ALIGNMENT = 2 

1519 

1520 class RTF_DBM_TX_POWER(__RadioTapField): 

1521 BIT_NUMBER = 10 

1522 STRUCTURE = "<b" 

1523 ALIGNMENT = 2 

1524 

1525 class RTF_ANTENNA(__RadioTapField): 

1526 BIT_NUMBER = 11 

1527 STRUCTURE = "<B" 

1528 

1529 class RTF_DB_ANTSIGNAL(__RadioTapField): 

1530 BIT_NUMBER = 12 

1531 STRUCTURE = "<B" 

1532 

1533 class RTF_DB_ANTNOISE(__RadioTapField): 

1534 BIT_NUMBER = 13 

1535 STRUCTURE = "<B" 

1536 

1537## # official assignment, clashes with RTF_FCS_IN_HEADER 

1538## class RTF_RX_FLAGS(__RadioTapField): 

1539## BIT_NUMBER = 14 

1540## STRUCTURE = "<H" 

1541## ALIGNMENT = 2 

1542 

1543 # clashes with RTF_RX_FLAGS 

1544 class RTF_FCS_IN_HEADER(__RadioTapField): 

1545 BIT_NUMBER = 14 

1546 STRUCTURE = "<L" 

1547 ALIGNMENT = 4 

1548 

1549 # clashes with HARDWARE_QUEUE 

1550 class RTF_TX_FLAGS(__RadioTapField): 

1551 BIT_NUMBER = 15 

1552 STRUCTURE = "<H" 

1553 ALIGNMENT = 2 

1554 

1555## # clashes with TX_FLAGS 

1556## class RTF_HARDWARE_QUEUE(__RadioTapField): 

1557## BIT_NUMBER = 15 

1558## STRUCTURE = "<B" 

1559## ALIGNMENT = 1 

1560 

1561 # clashes with RSSI 

1562 class RTF_RTS_RETRIES(__RadioTapField): 

1563 BIT_NUMBER = 16 

1564 STRUCTURE = "<B" 

1565 

1566## # clashes with RTS_RETRIES  

1567## class RTF_RSSI(__RadioTapField): 

1568## BIT_NUMBER = 16 

1569## STRUCTURE = "<H" 

1570## ALIGNMENT = 1 

1571 

1572 class RTF_DATA_RETRIES(__RadioTapField): 

1573 BIT_NUMBER = 17 

1574 STRUCTURE = "<B" 

1575 

1576 class RTF_XCHANNEL(__RadioTapField): 

1577 BIT_NUMBER = 18 

1578 STRUCTURE = "<LHBB" 

1579 ALIGNMENT = 4 

1580 

1581 class RTF_EXT(__RadioTapField): 

1582 BIT_NUMBER = 31 

1583 STRUCTURE = [] 

1584 

1585 # Sort the list so the 'for' statement walk the list in the right order 

1586 radiotap_fields = __RadioTapField.__subclasses__() 

1587 radiotap_fields.sort(key= lambda x: x.BIT_NUMBER) 

1588 

1589 def __init__(self, aBuffer = None): 

1590 header_size = self.__HEADER_BASE_SIZE 

1591 tail_size = 0 

1592 

1593 if aBuffer: 

1594 length = struct.unpack('<H', aBuffer[2:4])[0] 

1595 header_size=length 

1596 

1597 ProtocolPacket.__init__(self, header_size, tail_size) 

1598 self.load_packet(aBuffer) 

1599 else: 

1600 ProtocolPacket.__init__(self, header_size, tail_size) 

1601 self.set_version(0) 

1602 self.__set_present(0x00000000) 

1603 

1604 def get_header_length(self): 

1605 'Return the RadioTap header \'length\' field' 

1606 self.__update_header_length() 

1607 return self.header.get_word(2, "<") 

1608 

1609 def get_version(self): 

1610 'Return the \'version\' field' 

1611 b = self.header.get_byte(0) 

1612 return b 

1613 

1614 def set_version(self, value): 

1615 'Set the \'version\' field' 

1616 nb = (value & 0xFF) 

1617 self.header.set_byte(0, nb) 

1618 

1619 nb = (value & 0xFF) 

1620 

1621 def get_present(self, offset=_BASE_PRESENT_FLAGS_OFFSET): 

1622 "Return RadioTap present bitmap field" 

1623 present = self.header.get_long(offset, "<") 

1624 return present 

1625 

1626 def __set_present(self, value): 

1627 "Set RadioTap present field bit" 

1628 self.header.set_long(4, value) 

1629 

1630 def get_present_bit(self, field, offset=4): 

1631 'Get a \'present\' field bit' 

1632 present=self.get_present(offset) 

1633 return not not (2**field.BIT_NUMBER & present) 

1634 

1635 def __set_present_bit(self, field): 

1636 'Set a \'present\' field bit' 

1637 npresent=2**field.BIT_NUMBER | self.get_present() 

1638 self.header.set_long(4, npresent,'<') 

1639 

1640 def __unset_present_bit(self, field): 

1641 'Unset a \'present\' field bit' 

1642 npresent=~(2**field.BIT_NUMBER) & self.get_present() 

1643 self.header.set_long(4, npresent,'<') 

1644 

1645 def __align(self, val, align): 

1646 return ( (((val) + ((align) - 1)) & ~((align) - 1)) - val ) 

1647 

1648 def __get_field_position(self, field): 

1649 

1650 offset = RadioTap._BASE_PRESENT_FLAGS_OFFSET 

1651 extra_present_flags_count = 0 

1652 while self.get_present_bit(RadioTap.RTF_EXT, offset): 

1653 offset += RadioTap._PRESENT_FLAGS_SIZE 

1654 extra_present_flags_count += 1 

1655 

1656 field_position = self.__HEADER_BASE_SIZE + (RadioTap._BASE_PRESENT_FLAGS_OFFSET * extra_present_flags_count) 

1657 

1658 for f in self.radiotap_fields: 1658 ↛ 1667line 1658 didn't jump to line 1667, because the loop on line 1658 didn't complete

1659 field_position += self.__align(field_position, f.ALIGNMENT) 

1660 if f == field: 

1661 return field_position 

1662 

1663 if self.get_present_bit(f): 

1664 total_length = struct.calcsize(f.STRUCTURE) 

1665 field_position += total_length 

1666 

1667 return None 

1668 

1669 def unset_field( self, field): 

1670 is_present=self.get_present_bit(field) 

1671 if is_present is False: 1671 ↛ 1672line 1671 didn't jump to line 1672, because the condition on line 1671 was never true

1672 return False 

1673 

1674 byte_pos=self.__get_field_position(field) 

1675 if not byte_pos: 1675 ↛ 1676line 1675 didn't jump to line 1676, because the condition on line 1675 was never true

1676 return False 

1677 

1678 self.__unset_present_bit(field) 

1679 

1680 header=self.get_header_as_string() 

1681 total_length = struct.calcsize(field.STRUCTURE) 

1682 header=header[:byte_pos]+header[byte_pos+total_length:] 

1683 

1684 self.load_header(header) 

1685 

1686 def __get_field_values( self, field ): 

1687 is_present=self.get_present_bit(field) 

1688 if is_present is False: 

1689 return None 

1690 

1691 byte_pos=self.__get_field_position(field) 

1692 header=self.get_header_as_string() 

1693 total_length=struct.calcsize(field.STRUCTURE) 

1694 v=header[ byte_pos:byte_pos+total_length ] 

1695 

1696 field_values = struct.unpack(field.STRUCTURE, v) 

1697 

1698 return field_values 

1699 

1700 def __set_field_values( self, field, values ): 

1701 if not hasattr(values,'__iter__'): 1701 ↛ 1702line 1701 didn't jump to line 1702, because the condition on line 1701 was never true

1702 raise Exception("arg 'values' is not iterable") 

1703 

1704 # It's for to known the qty of argument of a structure 

1705 num_fields=len(''.join(c for c in field.STRUCTURE if c not in '=@!<>')) 

1706 

1707 if len(values)!=num_fields: 1707 ↛ 1708line 1707 didn't jump to line 1708, because the condition on line 1707 was never true

1708 raise Exception("Field %s has exactly %d items"%(str(field),struct.calcsize(field.STRUCTURE))) 

1709 

1710 is_present=self.get_present_bit(field) 

1711 if is_present is False: 

1712 self.__set_present_bit(field) 

1713 

1714 byte_pos=self.__get_field_position(field) 

1715 header=self.get_header_as_string() 

1716 total_length=struct.calcsize(field.STRUCTURE) 

1717 

1718 new_str = struct.pack(field.STRUCTURE, *values) 

1719 

1720 if is_present is True: 

1721 header=header[:byte_pos]+new_str+header[byte_pos+total_length:] 

1722 else: 

1723 header=header[:byte_pos]+new_str+header[byte_pos:] 

1724 self.load_header(header) 

1725 

1726 

1727 def set_tsft( self, nvalue ): 

1728 "Set the Value in microseconds of the MAC's 64-bit 802.11 "\ 

1729 "Time Synchronization Function timer when the first bit of "\ 

1730 "the MPDU arrived at the MAC" 

1731 self.__set_field_values(RadioTap.RTF_TSFT, [nvalue]) 

1732 

1733 def get_tsft( self ): 

1734 "Get the Value in microseconds of the MAC's 64-bit 802.11 "\ 

1735 "Time Synchronization Function timer when the first bit of "\ 

1736 "the MPDU arrived at the MAC" 

1737 

1738 values=self.__get_field_values(RadioTap.RTF_TSFT) 

1739 if not values: 

1740 return None 

1741 return values[0] 

1742 

1743 def set_flags( self, nvalue ): 

1744 "Set the properties of transmitted and received frames." 

1745 self.__set_field_values(self.RTF_FLAGS, [nvalue]) 

1746 

1747 def get_flags( self ): 

1748 "Get the properties of transmitted and received frames." 

1749 values=self.__get_field_values(self.RTF_FLAGS) 

1750 if not values: 1750 ↛ 1751line 1750 didn't jump to line 1751, because the condition on line 1750 was never true

1751 return None 

1752 return values[0] 

1753 

1754 def set_rate( self, nvalue ): 

1755 "Set the TX/RX data rate in 500 Kbps units" 

1756 

1757 self.__set_field_values(self.RTF_RATE, [nvalue]) 

1758 

1759 def get_rate( self ): 

1760 "Get the TX/RX data rate in 500 Kbps units" 

1761 

1762 values=self.__get_field_values(self.RTF_RATE) 

1763 if not values: 1763 ↛ 1764line 1763 didn't jump to line 1764, because the condition on line 1763 was never true

1764 return None 

1765 return values[0] 

1766 

1767 def set_channel( self, freq, flags ): 

1768 "Set the channel Tx/Rx frequency in MHz and the channel flags" 

1769 

1770 self.__set_field_values(self.RTF_CHANNEL, [freq, flags]) 

1771 

1772 def get_channel( self ): 

1773 "Get the TX/RX data rate in 500 Kbps units" 

1774 

1775 values=self.__get_field_values(self.RTF_CHANNEL) 

1776 

1777 return values 

1778 

1779 def set_FHSS( self, hop_set, hop_pattern ): 

1780 "Set the hop set and pattern for frequency-hopping radios" 

1781 

1782 self.__set_field_values(self.RTF_FHSS, [hop_set, hop_pattern]) 

1783 

1784 def get_FHSS( self ): 

1785 "Get the hop set and pattern for frequency-hopping radios" 

1786 

1787 values=self.__get_field_values(self.RTF_FHSS) 

1788 

1789 return values 

1790 

1791 def set_dBm_ant_signal( self, signal ): 

1792 "Set the RF signal power at the antenna, decibel difference from an "\ 

1793 "arbitrary, fixed reference." 

1794 

1795 self.__set_field_values(self.RTF_DBM_ANTSIGNAL, [signal]) 

1796 

1797 def get_dBm_ant_signal( self ): 

1798 "Get the RF signal power at the antenna, decibel difference from an "\ 

1799 "arbitrary, fixed reference." 

1800 

1801 values=self.__get_field_values(self.RTF_DBM_ANTSIGNAL) 

1802 if not values: 

1803 return None 

1804 return values[0] 

1805 

1806 def set_dBm_ant_noise( self, signal ): 

1807 "Set the RF noise power at the antenna, decibel difference from an "\ 

1808 "arbitrary, fixed reference." 

1809 

1810 self.__set_field_values(self.RTF_DBM_ANTNOISE, [signal]) 

1811 

1812 def get_dBm_ant_noise( self ): 

1813 "Get the RF noise power at the antenna, decibel difference from an "\ 

1814 "arbitrary, fixed reference." 

1815 

1816 values=self.__get_field_values(self.RTF_DBM_ANTNOISE) 

1817 if not values: 

1818 return None 

1819 return values[0] 

1820 

1821 def set_lock_quality( self, quality ): 

1822 "Set the quality of Barker code lock. "\ 

1823 "Called 'Signal Quality' in datasheets. " 

1824 

1825 self.__set_field_values(self.RTF_LOCK_QUALITY, [quality]) 

1826 

1827 def get_lock_quality( self ): 

1828 "Get the quality of Barker code lock. "\ 

1829 "Called 'Signal Quality' in datasheets. " 

1830 

1831 values=self.__get_field_values(self.RTF_LOCK_QUALITY) 

1832 if not values: 

1833 return None 

1834 return values[0] 

1835 

1836 def set_tx_attenuation( self, power ): 

1837 "Set the transmit power expressed as unitless distance from max power "\ 

1838 "set at factory calibration. 0 is max power." 

1839 

1840 self.__set_field_values(self.RTF_TX_ATTENUATION, [power]) 

1841 

1842 def get_tx_attenuation( self ): 

1843 "Set the transmit power expressed as unitless distance from max power "\ 

1844 "set at factory calibration. 0 is max power." 

1845 

1846 values=self.__get_field_values(self.RTF_TX_ATTENUATION) 

1847 if not values: 

1848 return None 

1849 return values[0] 

1850 

1851 def set_dB_tx_attenuation( self, power ): 

1852 "Set the transmit power expressed as decibel distance from max power "\ 

1853 "set at factory calibration. 0 is max power. " 

1854 

1855 self.__set_field_values(self.RTF_DB_TX_ATTENUATION, [power]) 

1856 

1857 def get_dB_tx_attenuation( self ): 

1858 "Set the transmit power expressed as decibel distance from max power "\ 

1859 "set at factory calibration. 0 is max power. " 

1860 

1861 values=self.__get_field_values(self.RTF_DB_TX_ATTENUATION) 

1862 if not values: 

1863 return None 

1864 return values[0] 

1865 

1866 def set_dBm_tx_power( self, power ): 

1867 "Set the transmit power expressed as dBm (decibels from a 1 milliwatt"\ 

1868 " reference). This is the absolute power level measured at the "\ 

1869 "antenna port." 

1870 

1871 self.__set_field_values(self.RTF_DBM_TX_POWER, [power]) 

1872 

1873 def get_dBm_tx_power( self ): 

1874 "Get the transmit power expressed as dBm (decibels from a 1 milliwatt"\ 

1875 " reference). This is the absolute power level measured at the "\ 

1876 "antenna port." 

1877 

1878 values=self.__get_field_values(self.RTF_DBM_TX_POWER) 

1879 if not values: 

1880 return None 

1881 return values[0] 

1882 

1883 def set_antenna( self, antenna_index ): 

1884 "Set Rx/Tx antenna index for this packet. "\ 

1885 "The first antenna is antenna 0. "\ 

1886 

1887 self.__set_field_values(self.RTF_ANTENNA, [antenna_index]) 

1888 

1889 def get_antenna( self ): 

1890 "Set Rx/Tx antenna index for this packet. "\ 

1891 "The first antenna is antenna 0. "\ 

1892 

1893 values=self.__get_field_values(self.RTF_ANTENNA) 

1894 if not values: 1894 ↛ 1895line 1894 didn't jump to line 1895, because the condition on line 1894 was never true

1895 return None 

1896 return values[0] 

1897 

1898 def set_dB_ant_signal( self, signal ): 

1899 "Set the RF signal power at the antenna, decibel difference from an "\ 

1900 "arbitrary, fixed reference." 

1901 

1902 self.__set_field_values(self.RTF_DB_ANTSIGNAL, [signal]) 

1903 

1904 def get_dB_ant_signal( self ): 

1905 "Get the RF signal power at the antenna, decibel difference from an "\ 

1906 "arbitrary, fixed reference." 

1907 

1908 values=self.__get_field_values(self.RTF_DB_ANTSIGNAL) 

1909 if not values: 

1910 return None 

1911 return values[0] 

1912 

1913 def set_dB_ant_noise( self, signal ): 

1914 "Set the RF noise power at the antenna, decibel difference from an "\ 

1915 "arbitrary, fixed reference." 

1916 

1917 self.__set_field_values(self.RTF_DB_ANTNOISE, [signal]) 

1918 

1919 def get_dB_ant_noise( self ): 

1920 "Get the RF noise power at the antenna, decibel difference from an "\ 

1921 "arbitrary, fixed reference." 

1922 

1923 values=self.__get_field_values(self.RTF_DB_ANTNOISE) 

1924 if not values: 

1925 return None 

1926 return values[0] 

1927 

1928## def set_rx_flags( self, flags ): 

1929## "Set the properties of received frames."  

1930## 

1931## self.__set_field_values(self.RTF_RX_FLAGS, [flags]) 

1932##  

1933## def get_rx_flags( self ): 

1934## "Get the properties of received frames."  

1935## 

1936## values=self.__get_field_values(self.RTF_RX_FLAGS) 

1937## if not values: 

1938## return None 

1939## return values[0] 

1940 

1941 def set_FCS_in_header( self, fcs ): 

1942 "Set the Field containing the FCS of the frame (instead of it being "\ 

1943 "appended to the frame as it would appear on the air.) " 

1944 

1945 self.__set_field_values(self.RTF_FCS_IN_HEADER, [fcs]) 

1946 

1947 def get_FCS_in_header( self ): 

1948 "Get the Field containing the FCS of the frame (instead of it being "\ 

1949 "appended to the frame as it would appear on the air.) " 

1950 

1951 values=self.__get_field_values(self.RTF_FCS_IN_HEADER) 

1952 if not values: 

1953 return None 

1954 return values[0] 

1955 

1956## def set_RSSI( self, rssi, max_rssi ): 

1957## "Set the received signal strength and the maximum for the hardware."  

1958##  

1959## self.__set_field_values(self.RTF_RSSI, [rssi, max_rssi]) 

1960##  

1961## def get_RSSI( self ): 

1962## "Get the received signal strength and the maximum for the hardware."  

1963##  

1964## values=self.__get_field_values(self.RTF_RSSI) 

1965##  

1966## return values 

1967 

1968 def set_RTS_retries( self, retries): 

1969 "Set the number of RTS retries a transmitted frame used." 

1970 

1971 self.__set_field_values(self.RTF_RTS_RETRIES, [retries]) 

1972 

1973 def get_RTS_retries( self ): 

1974 "Get the number of RTS retries a transmitted frame used." 

1975 

1976 values=self.__get_field_values(self.RTF_RTS_RETRIES) 

1977 if not values: 

1978 return None 

1979 return values[0] 

1980 

1981 def set_tx_flags( self, flags ): 

1982 "Set the properties of transmitted frames." 

1983 

1984 self.__set_field_values(self.RTF_TX_FLAGS, [flags]) 

1985 

1986 def get_tx_flags( self ): 

1987 "Get the properties of transmitted frames." 

1988 

1989 values=self.__get_field_values(self.RTF_TX_FLAGS) 

1990 if not values: 

1991 return None 

1992 return values[0] 

1993 

1994 def set_xchannel( self, flags, freq, channel, maxpower ): 

1995 "Set extended channel information: flags, freq, channel and maxpower" 

1996 

1997 self.__set_field_values(self.RTF_XCHANNEL, [flags, freq, channel, maxpower] ) 

1998 

1999 def get_xchannel( self ): 

2000 "Get extended channel information: flags, freq, channel and maxpower" 

2001 

2002 values=self.__get_field_values(field=self.RTF_XCHANNEL) 

2003 

2004 return values 

2005 

2006 def set_data_retries( self, retries ): 

2007 "Set the number of data retries a transmitted frame used." 

2008 

2009 self.__set_field_values(self.RTF_DATA_RETRIES, [retries]) 

2010 

2011 def get_data_retries( self ): 

2012 "Get the number of data retries a transmitted frame used." 

2013 

2014 values=self.__get_field_values(self.RTF_DATA_RETRIES) 

2015 if not values: 

2016 return None 

2017 return values[0] 

2018 

2019 def set_hardware_queue( self, queue ): 

2020 "Set the hardware queue to send the frame on." 

2021 

2022 self.__set_field_values(self.RTF_HARDWARE_QUEUE, [queue]) 

2023 

2024## def get_hardware_queue( self ): 

2025## "Get the hardware queue to send the frame on."  

2026## 

2027## values=self.__get_field_values(self.RTF_HARDWARE_QUEUE) 

2028## if not values: 

2029## return None 

2030## return values[0] 

2031 

2032 def __update_header_length(self): 

2033 'Update the RadioTap header length field with the real size' 

2034 self.header.set_word(2, self.get_header_size(), "<") 

2035 

2036 def get_packet(self): 

2037 self.__update_header_length() 

2038 return ProtocolPacket.get_packet(self) 

2039 

2040class Dot11ManagementFrame(ProtocolPacket): 

2041 '802.11 Management Frame' 

2042 

2043 def __init__(self, aBuffer = None): 

2044 header_size = 22 

2045 tail_size = 0 

2046 

2047 ProtocolPacket.__init__(self, header_size, tail_size) 

2048 if(aBuffer): 2048 ↛ exitline 2048 didn't return from function '__init__', because the condition on line 2048 was never false

2049 self.load_packet(aBuffer) 

2050 

2051 def get_duration(self): 

2052 'Return 802.11 Management frame \'Duration\' field' 

2053 b = self.header.get_word(0, "<") 

2054 return b 

2055 

2056 def set_duration(self, value): 

2057 'Set the 802.11 Management frame \'Duration\' field' 

2058 # set the bits 

2059 nb = value & 0xFFFF 

2060 self.header.set_word(0, nb, "<") 

2061 

2062 def get_destination_address(self): 

2063 'Return 802.11 Management frame \'Destination Address\' field as a 6 bytes array' 

2064 return self.header.get_bytes()[2:8] 

2065 

2066 def set_destination_address(self, value): 

2067 'Set 802.11 Management frame \'Destination Address\' field as a 6 bytes array' 

2068 for i in range(0, 6): 

2069 self.header.set_byte(2+i, value[i]) 

2070 

2071 def get_source_address(self): 

2072 'Return 802.11 Management frame \'Source Address\' field as a 6 bytes array' 

2073 return self.header.get_bytes()[8:14] 

2074 

2075 def set_source_address(self, value): 

2076 'Set 802.11 Management frame \'Source Address\' field as a 6 bytes array' 

2077 for i in range(0, 6): 

2078 self.header.set_byte(8+i, value[i]) 

2079 

2080 def get_bssid(self): 

2081 'Return 802.11 Management frame \'BSSID\' field as a 6 bytes array' 

2082 return self.header.get_bytes()[14: 20] 

2083 

2084 def set_bssid(self, value): 

2085 'Set 802.11 Management frame \'BSSID\' field as a 6 bytes array' 

2086 for i in range(0, 6): 

2087 self.header.set_byte(14+i, value[i]) 

2088 

2089 def get_sequence_control(self): 

2090 'Return 802.11 Management frame \'Sequence Control\' field' 

2091 b = self.header.get_word(20, "<") 

2092 return b 

2093 

2094 def set_sequence_control(self, value): 

2095 'Set the 802.11 Management frame \'Sequence Control\' field' 

2096 # set the bits 

2097 nb = value & 0xFFFF 

2098 self.header.set_word(20, nb, "<") 

2099 

2100 def get_fragment_number(self): 

2101 'Return 802.11 Management frame \'Fragment Number\' subfield' 

2102 

2103 b = self.get_sequence_control() 

2104 return (b&0x000F) 

2105 

2106 def set_fragment_number(self, value): 

2107 'Set the 802.11 Management frame \'Fragment Number\' subfield' 

2108 # clear the bits 

2109 mask = (~0x000F) & 0xFFFF 

2110 masked = self.header.get_word(20, "<") & mask 

2111 # set the bits  

2112 nb = masked | (value & 0x000F) 

2113 self.header.set_word(20, nb, "<") 

2114 

2115 def get_sequence_number(self): 

2116 'Return 802.11 Management frame \'Sequence Number\' subfield' 

2117 

2118 b = self.get_sequence_control() 

2119 return ((b>>4) & 0xFFF) 

2120 

2121 def set_sequence_number(self, value): 

2122 'Set the 802.11 Management frame \'Sequence Number\' subfield' 

2123 # clear the bits 

2124 mask = (~0xFFF0) & 0xFFFF 

2125 masked = self.header.get_word(20, "<") & mask 

2126 # set the bits  

2127 nb = masked | ((value & 0x0FFF ) << 4 ) 

2128 self.header.set_word(20, nb, "<") 

2129 

2130 def get_frame_body(self): 

2131 'Return 802.11 Management frame \'Frame Body\' field' 

2132 

2133 return self.get_body_as_string() 

2134 

2135 def set_frame_body(self, data): 

2136 'Set 802.11 Management frame \'Frame Body\' field' 

2137 

2138 self.load_body(data) 

2139 

2140class DOT11_MANAGEMENT_ELEMENTS(): 

2141 SSID = 0 

2142 SUPPORTED_RATES = 1 

2143 FH_PARAMETER_SET = 2 

2144 DS_PARAMETER_SET = 3 

2145 CF_PARAMETER_SET = 4 

2146 TIM = 5 

2147 IBSS_PARAMETER_SET = 6 

2148 COUNTRY = 7 

2149 HOPPING_PARAMETER = 8 

2150 HOPPING_TABLE = 9 

2151 REQUEST = 10 

2152 BSS_LOAD = 11 

2153 EDCA_PARAMETER_SET = 12 

2154 TSPEC = 13 

2155 TCLAS = 14 

2156 SCHEDULE = 15 

2157 CHALLENGE_TEXT = 16 

2158 # RESERVED 17-31  

2159 POWER_CONSTRAINT = 32 

2160 POWER_CAPABILITY = 33 

2161 TPC_REQUEST = 34 

2162 TPC_REPORT = 35 

2163 SUPPORTED_CHANNELS = 36 

2164 CHANNEL_SWITCH_ANN = 37 

2165 MEASURE_REQ = 38 

2166 MEASURE_REP = 39 

2167 QUIET = 40 

2168 IBSS_DFS = 41 

2169 ERP_INFO = 42 

2170 TS_DELAY = 43 

2171 TCLAS_PROCESSING = 44 

2172 #RESERVED 45 # See: IEEE 802.11n 

2173 QOS_CAPABILITY = 46 

2174 #RESERVED 47 # See: IEEE 802.11g 

2175 RSN = 48 

2176 #RESERVED 49 

2177 EXT_SUPPORTED_RATES = 50 

2178 #RESERVED 51-126 

2179 EXTENDED_CAPABILITIES = 127 

2180 #RESERVED 128-220 

2181 VENDOR_SPECIFIC = 221 

2182 #RESERVED 222-255 

2183 

2184class Dot11ManagementHelper(ProtocolPacket): 

2185 

2186 def __init__(self, header_size, tail_size, aBuffer = None): 

2187 self.__HEADER_BASE_SIZE=header_size 

2188 

2189 if aBuffer: 2189 ↛ 2196line 2189 didn't jump to line 2196, because the condition on line 2189 was never false

2190 elements_length=self.__calculate_elements_length(aBuffer[self.__HEADER_BASE_SIZE:]) 

2191 header_size+=elements_length 

2192 

2193 ProtocolPacket.__init__(self, header_size, tail_size) 

2194 self.load_packet(aBuffer) 

2195 else: 

2196 ProtocolPacket.__init__(self, header_size, tail_size) 

2197 

2198 def _find_element(self, elements, element_id ): 

2199 remaining=len(elements) 

2200 

2201 offset=0 

2202 while remaining > 0: 

2203 (id,length)=struct.unpack("!BB",elements[offset:offset+2]) 

2204 if element_id is None: 

2205 pass # through the whole list returning the length 

2206 elif id==element_id: 

2207 yield (0,offset,length+2) # == 

2208 length+=2 #id+length 

2209 offset+=length 

2210 if length>remaining: 2210 ↛ 2212line 2210 didn't jump to line 2212, because the condition on line 2210 was never true

2211 # Error!! 

2212 length = remaining 

2213 remaining-=length 

2214 # < Not found 

2215 yield (-1, offset, None) 

2216 

2217 def __calculate_elements_length(self, elements): 

2218 gen_tp=self._find_element(elements, None ) 

2219 (match,offset,length)=next(gen_tp) 

2220 if match != -1: 2220 ↛ 2222line 2220 didn't jump to line 2222, because the condition on line 2220 was never true

2221 # element_id is None, then __find_tagged_parameter must return -1 

2222 raise Exception("Internal Error %s"%match) 

2223 return offset 

2224 

2225 def _get_elements_generator(self, element_id): 

2226 elements=self.get_header_as_string()[self.__HEADER_BASE_SIZE:] 

2227 gen_tp=self._find_element(elements, element_id ) 

2228 while True: 

2229 (match,offset,length)=next(gen_tp) 

2230 if match != 0: 

2231 return 

2232 value_offset=offset+2 

2233 value_end=offset+length 

2234 value=elements[value_offset:value_end] 

2235 yield value 

2236 

2237 def _get_element(self, element_id): 

2238 gen_get_element=self._get_elements_generator(element_id) 

2239 try: 

2240 s=next(gen_get_element) 

2241 

2242 if s is None: 2242 ↛ 2243line 2242 didn't jump to line 2243, because the condition on line 2242 was never true

2243 raise Exception("gen_get_element salio con None in _get_element!!!") 

2244 

2245 return s 

2246 except StopIteration: 

2247 pass 

2248 

2249 return None 

2250 

2251 def delete_element(self, element_id, multiple = False): 

2252 header=self.get_header_as_string() 

2253 elements=header[self.__HEADER_BASE_SIZE:] 

2254 gen_tp=self._find_element(elements, element_id ) 

2255 found=False 

2256 while True: 

2257 (match,offset,length)=next(gen_tp) 

2258 if match != 0: 

2259 break 

2260 start=self.__HEADER_BASE_SIZE+offset 

2261 header=header[:start]+header[start+length:] 

2262 found=True 

2263 if multiple is False: 

2264 break 

2265 

2266 if not found: 

2267 return False 

2268 

2269 self.load_header(header) 

2270 return True 

2271 

2272 def _set_element(self, element_id, value, replace = True): 

2273 parameter=struct.pack('BB%ds'%len(value),element_id,len(value),value) 

2274 

2275 header=self.get_header_as_string() 

2276 elements=header[self.__HEADER_BASE_SIZE:] 

2277 gen_tp=self._find_element(elements, element_id ) 

2278 found=False 

2279 while True: 

2280 (match,offset,length)=next(gen_tp) 

2281 start=self.__HEADER_BASE_SIZE+offset 

2282 if match == 0 and replace: 

2283 # Replace 

2284 header=header[:start]+parameter+header[start+length:] 

2285 found=True 

2286 break 

2287 elif match > 0: 2287 ↛ 2289,   2287 ↛ 22932 missed branches: 1) line 2287 didn't jump to line 2289, because the condition on line 2287 was never true, 2) line 2287 didn't jump to line 2293, because the condition on line 2287 was never false

2288 # Add 

2289 header=header[:start]+parameter+header[start:] 

2290 found=True 

2291 break 

2292 else: 

2293 break 

2294 if not found: 

2295 # Append (found<0 Not found) 

2296 header=header+parameter 

2297 self.load_header(header) 

2298 

2299class Dot11ManagementBeacon(Dot11ManagementHelper): 

2300 '802.11 Management Beacon Frame' 

2301 

2302 __HEADER_BASE_SIZE = 12 # minimal header size 

2303 

2304 def __init__(self, aBuffer = None): 

2305 header_size = self.__HEADER_BASE_SIZE 

2306 tail_size = 0 

2307 Dot11ManagementHelper.__init__(self, header_size, tail_size, aBuffer) 

2308 

2309 def get_timestamp(self): 

2310 'Return the 802.11 Management Beacon frame \'Timestamp\' field' 

2311 b = self.header.get_long_long(0, "<") 

2312 return b 

2313 

2314 def set_timestamp(self, value): 

2315 'Set the 802.11 Management Beacon frame \'Timestamp\' field' 

2316 # set the bits 

2317 nb = value & 0xFFFFFFFFFFFFFFFF 

2318 self.header.set_long_long(0, nb, "<") 

2319 

2320 def get_beacon_interval(self): 

2321 'Return the 802.11 Management Beacon frame \'Beacon Interval\' field' \ 

2322 'To convert it to seconds => secs = Beacon_Interval*1024/1000000' 

2323 

2324 b = self.header.get_word(8, "<") 

2325 return b 

2326 

2327 def set_beacon_interval(self, value): 

2328 'Set the 802.11 Management Beacon frame \'Beacon Interval\' field' 

2329 # set the bits 

2330 nb = value & 0xFFFF 

2331 self.header.set_word(8, nb, "<") 

2332 

2333 def get_capabilities(self): 

2334 'Return the 802.11 Management Beacon frame \'Capability information\' field. ' 

2335 

2336 b = self.header.get_word(10, "<") 

2337 return b 

2338 

2339 def set_capabilities(self, value): 

2340 'Set the 802.11 Management Beacon frame \'Capability Information\' field' 

2341 # set the bits 

2342 nb = value & 0xFFFF 

2343 self.header.set_word(10, nb, "<") 

2344 

2345 def get_ssid(self): 

2346 "Get the 802.11 Management SSID element. "\ 

2347 "The SSID element indicates the identity of an ESS or IBSS." 

2348 return self._get_element(DOT11_MANAGEMENT_ELEMENTS.SSID) 

2349 

2350 def set_ssid(self, ssid): 

2351 self._set_element(DOT11_MANAGEMENT_ELEMENTS.SSID,ssid) 

2352 

2353 def get_supported_rates(self, human_readable=False): 

2354 "Get the 802.11 Management Supported Rates element. "\ 

2355 "Specifies up to eight rates, then an Extended Supported Rate element "\ 

2356 "shall be generated to specify the remaining supported rates."\ 

2357 "If human_readable is True, the rates are returned in Mbit/sec" 

2358 s=self._get_element(DOT11_MANAGEMENT_ELEMENTS.SUPPORTED_RATES) 

2359 if s is None: 2359 ↛ 2360line 2359 didn't jump to line 2360, because the condition on line 2359 was never true

2360 return None 

2361 

2362 rates=struct.unpack('%dB'%len(s),s) 

2363 if not human_readable: 

2364 return rates 

2365 

2366 rates_Mbs=tuple([(x&0x7F)*0.5 for x in rates]) 

2367 return rates_Mbs 

2368 

2369 def set_supported_rates(self, rates): 

2370 "Set the 802.11 Management Supported Rates element. "\ 

2371 "Specifies a tuple or list with up to eight rates, then an "\ 

2372 "Extended Supported Rate element shall be generated to specify "\ 

2373 "the remaining supported rates." 

2374 qty_rates=len(rates) 

2375 if qty_rates>8: 2375 ↛ 2376line 2375 didn't jump to line 2376, because the condition on line 2375 was never true

2376 raise Exception("requires up to eight rates") 

2377 rates_string=struct.pack('B'*qty_rates,*rates) 

2378 self._set_element(DOT11_MANAGEMENT_ELEMENTS.SUPPORTED_RATES,rates_string) 

2379 

2380 def get_ds_parameter_set(self): 

2381 "Get the 802.11 Management DS Parameter set element. "\ 

2382 "Contains information to allow channel number identification for "\ 

2383 "STAs using a DSSS PHY." 

2384 s=self._get_element(DOT11_MANAGEMENT_ELEMENTS.DS_PARAMETER_SET) 

2385 if s is None: 2385 ↛ 2386line 2385 didn't jump to line 2386, because the condition on line 2385 was never true

2386 return None 

2387 

2388 (ch,)=struct.unpack('B',s) 

2389 

2390 return ch 

2391 

2392 def set_ds_parameter_set(self, channel): 

2393 "Set the 802.11 Management DS Parameter set element. "\ 

2394 "Contains information to allow channel number identification for "\ 

2395 "STAs using a DSSS PHY." 

2396 channel_string=struct.pack('B',channel) 

2397 self._set_element(DOT11_MANAGEMENT_ELEMENTS.DS_PARAMETER_SET,channel_string) 

2398 

2399 def get_rsn(self): 

2400 "Get the 802.11 Management Robust Security Network element." 

2401 s = self._get_element(DOT11_MANAGEMENT_ELEMENTS.RSN) 

2402 if s is None: 

2403 return None 

2404 return s 

2405 

2406 def set_rsn(self, data): 

2407 "Set the 802.11 Management Robust Security Network element." 

2408 self._set_element(DOT11_MANAGEMENT_ELEMENTS.RSN, data) 

2409 

2410 def get_erp(self): 

2411 "Get the 802.11 Management ERP (extended rate PHY) Information element." 

2412 s = self._get_element(DOT11_MANAGEMENT_ELEMENTS.ERP_INFO) 

2413 if s is None: 

2414 return None 

2415 

2416 (erp,) = struct.unpack('B',s) 

2417 

2418 return erp 

2419 

2420 def set_erp(self, erp): 

2421 "Set the 802.11 Management ERP (extended rate PHY) Inforamation "\ 

2422 "element." 

2423 erp_string = struct.pack('B',erp) 

2424 self._set_element(DOT11_MANAGEMENT_ELEMENTS.ERP_INFO, erp_string) 

2425 

2426 def get_country(self): 

2427 "Get the 802.11 Management Country element." \ 

2428 "Returns a tuple containing Country code, first channel number, "\ 

2429 "number of channels and maximum transmit power level" 

2430 s = self._get_element(DOT11_MANAGEMENT_ELEMENTS.COUNTRY) 

2431 if s is None: 

2432 return None 

2433 

2434 code, first, num, max = struct.unpack('3sBBB',s) 

2435 code = code.strip(' ') 

2436 return code, first, num, max 

2437 

2438 def set_country(self, code, first_channel, number_of_channels, max_power): 

2439 "Set the 802.11 Management Country element." 

2440 if len(code) > 3: 

2441 raise Exception("Country code must be up to 3 bytes long") 

2442 

2443 #Padding the country code 

2444 code += ' ' * (3-len(code)) 

2445 

2446 country_string = struct.pack('3sBBB', code, first_channel, 

2447 number_of_channels, max_power) 

2448 self._set_element(DOT11_MANAGEMENT_ELEMENTS.COUNTRY, country_string) 

2449 

2450 def get_vendor_specific(self): 

2451 "Get the 802.11 Management Vendor Specific elements "\ 

2452 "as a list of tuples." 

2453 "The Vendor Specific information element is used to carry "\ 

2454 "information not defined in the standard within a single "\ 

2455 "defined format" 

2456 

2457 vs=[] 

2458 gen_get_element=self._get_elements_generator(DOT11_MANAGEMENT_ELEMENTS.VENDOR_SPECIFIC) 

2459 try: 

2460 while 1: 

2461 s=next(gen_get_element) 

2462 

2463 if s is None: 2463 ↛ 2464line 2463 didn't jump to line 2464, because the condition on line 2463 was never true

2464 raise Exception("gen_get_element salio con None!!!") 

2465 

2466 # OUI is 3 bytes 

2467 oui=s[:3] 

2468 data=s[3:] 

2469 vs.append((oui,data)) 

2470 except StopIteration: 

2471 pass 

2472 

2473 return vs 

2474 

2475 def add_vendor_specific(self, oui, data): 

2476 "Set the 802.11 Management Vendor Specific element. "\ 

2477 "The Vendor Specific information element is used to carry "\ 

2478 "information not defined in the standard within a single "\ 

2479 "defined format" 

2480 

2481 # 3 is the OUI length 

2482 max_data_len=255-3 

2483 data_len=len(data) 

2484 

2485 if data_len>max_data_len: 2485 ↛ 2486line 2485 didn't jump to line 2486, because the condition on line 2485 was never true

2486 raise Exception("data allow up to %d bytes long" % max_data_len) 

2487 if len(oui) > 3: 2487 ↛ 2488line 2487 didn't jump to line 2488, because the condition on line 2487 was never true

2488 raise Exception("oui is three bytes long") 

2489 

2490 self._set_element(DOT11_MANAGEMENT_ELEMENTS.VENDOR_SPECIFIC,oui+data, replace=False) 

2491 

2492class Dot11ManagementProbeRequest(Dot11ManagementHelper): 

2493 '802.11 Management Probe Request Frame' 

2494 

2495 def __init__(self, aBuffer = None): 

2496 header_size = 0 

2497 tail_size = 0 

2498 Dot11ManagementHelper.__init__(self, header_size, tail_size, aBuffer) 

2499 

2500 def get_ssid(self): 

2501 "Get the 802.11 Management SSID element. "\ 

2502 "The SSID element indicates the identity of an ESS or IBSS." 

2503 return self._get_element(DOT11_MANAGEMENT_ELEMENTS.SSID) 

2504 

2505 def set_ssid(self, ssid): 

2506 self._set_element(DOT11_MANAGEMENT_ELEMENTS.SSID,ssid) 

2507 

2508 def get_supported_rates(self, human_readable=False): 

2509 "Get the 802.11 Management Supported Rates element. "\ 

2510 "Specifies up to eight rates, then an Extended Supported Rate element "\ 

2511 "shall be generated to specify the remaining supported rates."\ 

2512 "If human_readable is True, the rates are returned in Mbit/sec" 

2513 s=self._get_element(DOT11_MANAGEMENT_ELEMENTS.SUPPORTED_RATES) 

2514 if s is None: 2514 ↛ 2515line 2514 didn't jump to line 2515, because the condition on line 2514 was never true

2515 return None 

2516 

2517 rates=struct.unpack('%dB'%len(s),s) 

2518 if not human_readable: 

2519 return rates 

2520 

2521 rates_Mbs=tuple([(x&0x7F)*0.5 for x in rates]) 

2522 return rates_Mbs 

2523 

2524 def set_supported_rates(self, rates): 

2525 "Set the 802.11 Management Supported Rates element. "\ 

2526 "Specifies a tuple or list with up to eight rates, then an "\ 

2527 "Extended Supported Rate element shall be generated to specify "\ 

2528 "the remaining supported rates." 

2529 qty_rates=len(rates) 

2530 if qty_rates>8: 2530 ↛ 2531line 2530 didn't jump to line 2531, because the condition on line 2530 was never true

2531 raise Exception("requires up to eight rates") 

2532 rates_string=struct.pack('B'*qty_rates,*rates) 

2533 self._set_element(DOT11_MANAGEMENT_ELEMENTS.SUPPORTED_RATES,rates_string) 

2534 

2535class Dot11ManagementProbeResponse(Dot11ManagementBeacon): 

2536 '802.11 Management Probe Response Frame' 

2537 

2538 def __init__(self, aBuffer = None): 

2539 Dot11ManagementBeacon.__init__(self, aBuffer) 

2540 

2541class DOT11_REASON_CODES(): 

2542 # RESERVED = 0 

2543 UNSPECIFIED_REASON = 1 

2544 PREV_AUTH_NO_LONGER_VALID = 2 

2545 DEAUTH_STA_IS_LEAVING = 3 

2546 DISASS_DUE_TO_INACTIVITY = 4 

2547 DISASS_AP_UNABLE_HANDLE_ALL_STA = 5 

2548 C2_FRAME_FROM_NONAUTHENTICATED_STA = 6 

2549 C3_FRAME_FROM_NONASSOCIATED_STA = 7 

2550 DISSASS_STA_IS_LEAVING = 8 

2551 STA_REQ_NOT_AUTH_STA = 9 

2552 DISASS_POWER_CAP_IE_UNNACCEPTABLE = 10 

2553 DISASS_SUP_CH_IE_UNNACCEPTABLE = 11 

2554 # RESERVED = 12 

2555 INVALID_IE = 13 

2556 MIC_FAILURE = 14 

2557 FOUR_WAY_HANDSHAKE_TIMEOUT = 15 

2558 GROUP_KEY_HANDSHAKE_TIMEOUT = 16 

2559 IE_FOUR_WAY_HANDSHAKE_DIFFERENT = 17 

2560 INVALID_GROUP_CIPHER = 18 

2561 INVALID_PAIRWISE_CIPHER = 19 

2562 INVALID_AKMP = 20 

2563 UNSUPPORTED_RSN_IE_VERSION = 21 

2564 INVALID_RSN_IE_CAP = 22 

2565 X_AUTH_FAILED = 23 

2566 CIPHER_SUITE_REJECTED_SECURITY_POLICY = 24 

2567 # RESERVED = 25 - 31 

2568 DISASS_QOS_RELATED_REASON = 32 

2569 DISASS_QOS_UNSUFFICIENT_BANDWIDTH = 33 

2570 DISASS_EXCESSIVE_FRAMES_WITHOUT_ACK = 34 

2571 DISASS_STA_TX_OUTSIDE_TXOPS = 35 

2572 REQ_STA_LEAVING = 36 

2573 REQ_STA_NOT_WANT_MECHANISM = 37 

2574 REQ_STA_RECV_FRAMES_WHICH_SETUP_REQ = 38 

2575 REQ_STA_DUE_TIMEOUT = 39 

2576 STA_NOT_SUPPORT_CIPHER_SUITE = 45 

2577 # RESERVED = 46 - 65 535 

2578 

2579class Dot11ManagementDeauthentication(ProtocolPacket): 

2580 '802.11 Management Deauthentication Frame' 

2581 

2582 def __init__(self, aBuffer = None): 

2583 header_size = 2 

2584 tail_size = 0 

2585 if aBuffer: 2585 ↛ 2589line 2585 didn't jump to line 2589, because the condition on line 2585 was never false

2586 ProtocolPacket.__init__(self, header_size, tail_size) 

2587 self.load_packet(aBuffer) 

2588 else: 

2589 ProtocolPacket.__init__(self, header_size, tail_size) 

2590 

2591 def get_reason_code(self): 

2592 "Get the 802.11 Management Deauthentication or Disassociation Code." 

2593 return self.header.get_word(0, "<") 

2594 

2595 def set_reason_code(self, rc): 

2596 self.header.set_word(0, rc, "<") 

2597 

2598class DOT11_AUTH_ALGORITHMS(): 

2599 OPEN = 0 

2600 SHARED_KEY = 1 

2601 

2602class DOT11_AUTH_STATUS_CODES(): 

2603 SUCCESSFUL = 0 

2604 UNSPECIFIED_FAILURE = 1 

2605 # RESERVED = 2 - 9 

2606 CAP_REQ_UNSUPPORTED = 10 

2607 REASS_DENIED_CANNOT_CONFIRM_ASS_EXISTS = 11 

2608 ASS_DENIED_REASON_OUTSIDE_SCOPE_STANDARD = 12 

2609 STA_NOT_SUPPORT_AUTH_ALGORITHM = 13 

2610 AUTH_SEQ_OUT_OF_EXPECTED = 14 

2611 AUTH_REJECTED_CHALLENGE_FAILURE = 15 

2612 AUTH_REJECTED_TIMEOUT = 16 

2613 ASS_DENIED_AP_UNABLE_HANDLE_MORE_STA = 17 

2614 ASS_DENIED_STA_NOT_SUPPORTING_DATA_RATES = 18 

2615 ASS_DENIED_STA_NOT_SUPPORTING_SHORT_PREAMBLE = 19 

2616 ASS_DENIED_STA_NOT_SUPPORTING_PBCC_MODULATION = 20 

2617 ASS_DENIED_STA_NOT_SUPPORTING_CHANNEL_AGILITY = 21 

2618 ASS_REQUEST_REJECTED_SPACTRUM_MGT_CAP = 22 

2619 ASS_REQUEST_REJECTED_POWER_CAP_IE_UNNACCEPTABLE = 23 

2620 ASS_REQUEST_REJECTED_SUP_CH_IE_UNNACCEPTABLE = 24 

2621 ASS_DENIED_STA_NOT_SUPPORTING_SHORT_SLOT_TIME = 25 

2622 ASS_DENIED_STA_NOT_SUPPORTING_DSSS_OFDM = 26 

2623 # RESERVED = 27 - 31 

2624 UNSPECIFIED_QOS = 32 

2625 ASS_DENIED_QOS_UNSUFFICIENT_BANDWIDTH = 33 

2626 ASS_DENIED_EXCESSIVE_FRAME_LOST = 34 

2627 ASS_DENIED_STA_NOT_SUPPORT_QOS = 35 

2628 # RESERVED = 36 

2629 REQ_HAS_BEEN_DECLINED = 37 

2630 REQ_NOT_SUCCESSFUL_PARAM_INVALID_VALUE = 38 

2631 TSPEC = 39 

2632 INVALID_IE = 40 

2633 INVALID_GROUP_CIPHER = 41 

2634 INVALID_PAIRWISE_CIPHER = 42 

2635 INVALID_AKMP = 43 

2636 UNSUPPORTED_RSN_IE_VERSION = 44 

2637 INVALID_RSN_IE_CAP = 45 

2638 CIPHER_SUITE_REJECTED_SECURITY_POLICY = 46 

2639 TS_NOT_CREATED = 47 

2640 DIRECT_LINK_NOT_ALLOWED_BSS_POLICY = 48 

2641 DST_STA_NOT_PRESENT_IN_BSS = 49 

2642 DST_STA_NOT_QOS_STA = 50 

2643 ASS_DENIED_LISTEN_INTERVAL_TOO_LARGE = 51 

2644 # RESERVED = 52 - 65 535 

2645 

2646class Dot11ManagementAuthentication(Dot11ManagementHelper): 

2647 '802.11 Management Authentication Frame' 

2648 

2649 __HEADER_BASE_SIZE = 6 # minimal header size 

2650 

2651 def __init__(self, aBuffer = None): 

2652 header_size = self.__HEADER_BASE_SIZE 

2653 tail_size = 0 

2654 Dot11ManagementHelper.__init__(self, header_size, tail_size, aBuffer) 

2655 

2656 def get_authentication_algorithm(self): 

2657 "Get the 802.11 Management Authentication Algorithm." 

2658 return self.header.get_word(0, "<") 

2659 

2660 def set_authentication_algorithm(self, algorithm): 

2661 "Set the 802.11 Management Authentication Algorithm." 

2662 self.header.set_word(0, algorithm, "<") 

2663 

2664 def get_authentication_sequence(self): 

2665 "Get the 802.11 Management Authentication Sequence." 

2666 return self.header.get_word(2, "<") 

2667 

2668 def set_authentication_sequence(self, seq): 

2669 "Set the 802.11 Management Authentication Sequence." 

2670 self.header.set_word(2, seq, "<") 

2671 

2672 def get_authentication_status(self): 

2673 "Get the 802.11 Management Authentication Status." 

2674 return self.header.get_word(4, "<") 

2675 

2676 def set_authentication_status(self, status): 

2677 "Set the 802.11 Management Authentication Status." 

2678 self.header.set_word(4, status, "<") 

2679 

2680 def get_challenge_text(self): 

2681 return self._get_element(DOT11_MANAGEMENT_ELEMENTS.CHALLENGE_TEXT) 

2682 

2683 def set_challenge_text(self, challenge): 

2684 self._set_element(DOT11_MANAGEMENT_ELEMENTS.CHALLENGE_TEXT, challenge) 

2685 

2686 def get_vendor_specific(self): 

2687 "Get the 802.11 Management Vendor Specific elements "\ 

2688 "as a list of tuples." 

2689 "The Vendor Specific information element is used to carry "\ 

2690 "information not defined in the standard within a single "\ 

2691 "defined format" 

2692 

2693 vs=[] 

2694 gen_get_element=self._get_elements_generator(DOT11_MANAGEMENT_ELEMENTS.VENDOR_SPECIFIC) 

2695 try: 

2696 while 1: 

2697 s=next(gen_get_element) 

2698 

2699 if s is None: 2699 ↛ 2700line 2699 didn't jump to line 2700, because the condition on line 2699 was never true

2700 raise Exception("gen_get_element salio con None!!!") 

2701 

2702 # OUI is 3 bytes 

2703 oui=s[:3] 

2704 data=s[3:] 

2705 vs.append((oui,data)) 

2706 except StopIteration: 

2707 pass 

2708 

2709 return vs 

2710 

2711 def add_vendor_specific(self, oui, data): 

2712 "Set the 802.11 Management Vendor Specific element. "\ 

2713 "The Vendor Specific information element is used to carry "\ 

2714 "information not defined in the standard within a single "\ 

2715 "defined format" 

2716 

2717 # 3 is the OUI length 

2718 max_data_len=255-3 

2719 data_len=len(data) 

2720 

2721 if data_len>max_data_len: 2721 ↛ 2722line 2721 didn't jump to line 2722, because the condition on line 2721 was never true

2722 raise Exception("data allow up to %d bytes long" % max_data_len) 

2723 if len(oui) > 3: 2723 ↛ 2724line 2723 didn't jump to line 2724, because the condition on line 2723 was never true

2724 raise Exception("oui is three bytes long") 

2725 

2726 self._set_element(DOT11_MANAGEMENT_ELEMENTS.VENDOR_SPECIFIC,oui+data, replace=False) 

2727 

2728class Dot11ManagementDisassociation(Dot11ManagementDeauthentication): 

2729 '802.11 Management Disassociation Frame' 

2730 

2731 def __init__(self, aBuffer = None): 

2732 Dot11ManagementDeauthentication.__init__(self, aBuffer) 

2733 

2734class Dot11ManagementAssociationRequest(Dot11ManagementHelper): 

2735 '802.11 Management Association Request Frame' 

2736 

2737 __HEADER_BASE_SIZE = 4 # minimal header size 

2738 

2739 def __init__(self, aBuffer = None): 

2740 header_size = self.__HEADER_BASE_SIZE 

2741 tail_size = 0 

2742 Dot11ManagementHelper.__init__(self, header_size, tail_size, aBuffer) 

2743 

2744 def get_capabilities(self): 

2745 'Return the 802.11 Management Association Request Frame \'Capability information\' field. ' 

2746 b = self.header.get_word(0, "<") 

2747 return b 

2748 

2749 def set_capabilities(self, value): 

2750 'Set the 802.11 Management Association Request Frame \'Capability Information\' field' 

2751 # set the bits 

2752 nb = value & 0xFFFF 

2753 self.header.set_word(0, nb, "<") 

2754 

2755 def get_listen_interval(self): 

2756 'Return the 802.11 Management Association Request Frame \'Listen Interval\' field. ' 

2757 b = self.header.get_word(2, "<") 

2758 return b 

2759 

2760 def set_listen_interval(self, value): 

2761 'Set the 802.11 Management Association Request Frame \'Listen Interval\' field' 

2762 self.header.set_word(2, value, "<") 

2763 

2764 def get_ssid(self): 

2765 "Get the 802.11 Management SSID element. "\ 

2766 "The SSID element indicates the identity of an ESS or IBSS." 

2767 return self._get_element(DOT11_MANAGEMENT_ELEMENTS.SSID) 

2768 

2769 def set_ssid(self, ssid): 

2770 self._set_element(DOT11_MANAGEMENT_ELEMENTS.SSID,ssid) 

2771 

2772 def get_supported_rates(self, human_readable=False): 

2773 "Get the 802.11 Management Supported Rates element. "\ 

2774 "Specifies up to eight rates, then an Extended Supported Rate element "\ 

2775 "shall be generated to specify the remaining supported rates."\ 

2776 "If human_readable is True, the rates are returned in Mbit/sec" 

2777 s=self._get_element(DOT11_MANAGEMENT_ELEMENTS.SUPPORTED_RATES) 

2778 if s is None: 2778 ↛ 2779line 2778 didn't jump to line 2779, because the condition on line 2778 was never true

2779 return None 

2780 

2781 rates=struct.unpack('%dB'%len(s),s) 

2782 if not human_readable: 

2783 return rates 

2784 

2785 rates_Mbs=tuple([(x&0x7F)*0.5 for x in rates]) 

2786 return rates_Mbs 

2787 

2788 def set_supported_rates(self, rates): 

2789 "Set the 802.11 Management Supported Rates element. "\ 

2790 "Specifies a tuple or list with up to eight rates, then an "\ 

2791 "Extended Supported Rate element shall be generated to specify "\ 

2792 "the remaining supported rates." 

2793 qty_rates=len(rates) 

2794 if qty_rates>8: 2794 ↛ 2795line 2794 didn't jump to line 2795, because the condition on line 2794 was never true

2795 raise Exception("requires up to eight rates") 

2796 rates_string=struct.pack('B'*qty_rates,*rates) 

2797 self._set_element(DOT11_MANAGEMENT_ELEMENTS.SUPPORTED_RATES,rates_string) 

2798 

2799 def get_rsn(self): 

2800 "Get the 802.11 Management Robust Security Network element." 

2801 s = self._get_element(DOT11_MANAGEMENT_ELEMENTS.RSN) 

2802 if s is None: 2802 ↛ 2803line 2802 didn't jump to line 2803, because the condition on line 2802 was never true

2803 return None 

2804 return s 

2805 

2806 def set_rsn(self, data): 

2807 "Set the 802.11 Management Robust Security Network element." 

2808 self._set_element(DOT11_MANAGEMENT_ELEMENTS.RSN, data) 

2809 

2810 def get_vendor_specific(self): 

2811 "Get the 802.11 Management Vendor Specific elements "\ 

2812 "as a list of tuples." 

2813 "The Vendor Specific information element is used to carry "\ 

2814 "information not defined in the standard within a single "\ 

2815 "defined format" 

2816 

2817 vs=[] 

2818 gen_get_element=self._get_elements_generator(DOT11_MANAGEMENT_ELEMENTS.VENDOR_SPECIFIC) 

2819 try: 

2820 while 1: 

2821 s=next(gen_get_element) 

2822 

2823 if s is None: 2823 ↛ 2824line 2823 didn't jump to line 2824, because the condition on line 2823 was never true

2824 raise Exception("gen_get_element salio con None!!!") 

2825 

2826 # OUI is 3 bytes 

2827 oui=s[:3] 

2828 data=s[3:] 

2829 vs.append((oui,data)) 

2830 except StopIteration: 

2831 pass 

2832 

2833 return vs 

2834 

2835 def add_vendor_specific(self, oui, data): 

2836 "Set the 802.11 Management Vendor Specific element. "\ 

2837 "The Vendor Specific information element is used to carry "\ 

2838 "information not defined in the standard within a single "\ 

2839 "defined format" 

2840 

2841 # 3 is the OUI length 

2842 max_data_len=255-3 

2843 data_len=len(data) 

2844 

2845 if data_len>max_data_len: 2845 ↛ 2846line 2845 didn't jump to line 2846, because the condition on line 2845 was never true

2846 raise Exception("data allow up to %d bytes long" % max_data_len) 

2847 if len(oui) > 3: 2847 ↛ 2848line 2847 didn't jump to line 2848, because the condition on line 2847 was never true

2848 raise Exception("oui is three bytes long") 

2849 

2850 self._set_element(DOT11_MANAGEMENT_ELEMENTS.VENDOR_SPECIFIC,oui+data, replace=False) 

2851 

2852class Dot11ManagementAssociationResponse(Dot11ManagementHelper): 

2853 '802.11 Management Association Response Frame' 

2854 

2855 __HEADER_BASE_SIZE = 6 # minimal header size 

2856 

2857 def __init__(self, aBuffer = None): 

2858 header_size = self.__HEADER_BASE_SIZE 

2859 tail_size = 0 

2860 Dot11ManagementHelper.__init__(self, header_size, tail_size, aBuffer) 

2861 

2862 def get_capabilities(self): 

2863 'Return the 802.11 Management Association Response Frame \'Capability information\' field. ' 

2864 b = self.header.get_word(0, "<") 

2865 return b 

2866 

2867 def set_capabilities(self, value): 

2868 'Set the 802.11 Management Association Response Frame \'Capability Information\' field' 

2869 # set the bits 

2870 nb = value & 0xFFFF 

2871 self.header.set_word(0, nb, "<") 

2872 

2873 def get_status_code(self): 

2874 'Return the 802.11 Management Association Response Frame \'Status Code\' field. ' 

2875 b = self.header.get_word(2, "<") 

2876 return b 

2877 

2878 def set_status_code(self, value): 

2879 'Set the 802.11 Management Association Response Frame \'Status Code\' field' 

2880 self.header.set_word(2, value, "<") 

2881 

2882 def get_association_id(self): 

2883 'Return the 802.11 Management Association Response Frame \'Association Id\' field. ' 

2884 b = self.header.get_word(4, "<") 

2885 return b 

2886 

2887 def set_association_id(self, value): 

2888 'Set the 802.11 Management Association Response Frame \'Association Id\' field' 

2889 self.header.set_word(4, value, "<") 

2890 

2891 def get_supported_rates(self, human_readable=False): 

2892 "Get the 802.11 Management Supported Rates element. "\ 

2893 "Specifies up to eight rates, then an Extended Supported Rate element "\ 

2894 "shall be generated to specify the remaining supported rates."\ 

2895 "If human_readable is True, the rates are returned in Mbit/sec" 

2896 s=self._get_element(DOT11_MANAGEMENT_ELEMENTS.SUPPORTED_RATES) 

2897 if s is None: 2897 ↛ 2898line 2897 didn't jump to line 2898, because the condition on line 2897 was never true

2898 return None 

2899 

2900 rates=struct.unpack('%dB'%len(s),s) 

2901 if not human_readable: 

2902 return rates 

2903 

2904 rates_Mbs=tuple([(x&0x7F)*0.5 for x in rates]) 

2905 return rates_Mbs 

2906 

2907 def set_supported_rates(self, rates): 

2908 "Set the 802.11 Management Supported Rates element. "\ 

2909 "Specifies a tuple or list with up to eight rates, then an "\ 

2910 "Extended Supported Rate element shall be generated to specify "\ 

2911 "the remaining supported rates." 

2912 qty_rates=len(rates) 

2913 if qty_rates>8: 2913 ↛ 2914line 2913 didn't jump to line 2914, because the condition on line 2913 was never true

2914 raise Exception("requires up to eight rates") 

2915 rates_string=struct.pack('B'*qty_rates,*rates) 

2916 self._set_element(DOT11_MANAGEMENT_ELEMENTS.SUPPORTED_RATES,rates_string) 

2917 

2918 def get_vendor_specific(self): 

2919 "Get the 802.11 Management Vendor Specific elements "\ 

2920 "as a list of tuples." 

2921 "The Vendor Specific information element is used to carry "\ 

2922 "information not defined in the standard within a single "\ 

2923 "defined format" 

2924 

2925 vs=[] 

2926 gen_get_element=self._get_elements_generator(DOT11_MANAGEMENT_ELEMENTS.VENDOR_SPECIFIC) 

2927 try: 

2928 while 1: 

2929 s=next(gen_get_element) 

2930 

2931 if s is None: 2931 ↛ 2932line 2931 didn't jump to line 2932, because the condition on line 2931 was never true

2932 raise Exception("gen_get_element salio con None!!!") 

2933 

2934 # OUI is 3 bytes 

2935 oui=s[:3] 

2936 data=s[3:] 

2937 vs.append((oui,data)) 

2938 except StopIteration: 

2939 pass 

2940 

2941 return vs 

2942 

2943 def add_vendor_specific(self, oui, data): 

2944 "Set the 802.11 Management Vendor Specific element. "\ 

2945 "The Vendor Specific information element is used to carry "\ 

2946 "information not defined in the standard within a single "\ 

2947 "defined format" 

2948 

2949 # 3 is the OUI length 

2950 max_data_len=255-3 

2951 data_len=len(data) 

2952 if data_len>max_data_len: 2952 ↛ 2953line 2952 didn't jump to line 2953, because the condition on line 2952 was never true

2953 raise Exception("data allow up to %d bytes long" % max_data_len) 

2954 if len(oui) > 3: 2954 ↛ 2955line 2954 didn't jump to line 2955, because the condition on line 2954 was never true

2955 raise Exception("oui is three bytes long") 

2956 

2957 self._set_element(DOT11_MANAGEMENT_ELEMENTS.VENDOR_SPECIFIC,oui+data, replace=False) 

2958 

2959class Dot11ManagementReassociationRequest(Dot11ManagementHelper): 

2960 '802.11 Management Reassociation Request Frame' 

2961 

2962 __HEADER_BASE_SIZE = 10 # minimal header size 

2963 

2964 def __init__(self, aBuffer = None): 

2965 header_size = self.__HEADER_BASE_SIZE 

2966 tail_size = 0 

2967 Dot11ManagementHelper.__init__(self, header_size, tail_size, aBuffer) 

2968 

2969 def get_capabilities(self): 

2970 'Return the 802.11 Management Reassociation Request Frame \'Capability information\' field. ' 

2971 b = self.header.get_word(0, "<") 

2972 return b 

2973 

2974 def set_capabilities(self, value): 

2975 'Set the 802.11 Management Reassociation Request Frame \'Capability Information\' field' 

2976 # set the bits 

2977 nb = value & 0xFFFF 

2978 self.header.set_word(0, nb, "<") 

2979 

2980 def get_listen_interval(self): 

2981 'Return the 802.11 Management Reassociation Request Frame \'Listen Interval\' field. ' 

2982 b = self.header.get_word(2, "<") 

2983 return b 

2984 

2985 def set_listen_interval(self, value): 

2986 'Set the 802.11 Management Reassociation Request Frame \'Listen Interval\' field' 

2987 self.header.set_word(2, value, "<") 

2988 

2989 def get_current_ap(self): 

2990 'Return the 802.11 Management Reassociation Request Frame \'Current AP\' field.' 

2991 return self.header.get_bytes()[4:10] 

2992 

2993 def set_current_ap(self, value): 

2994 'Set the 802.11 Management Reassociation Request Frame \'Current AP\' field' 

2995 for i in range(0, 6): 

2996 self.header.set_byte(4+i, value[i]) 

2997 

2998 def get_ssid(self): 

2999 "Get the 802.11 Management SSID element. "\ 

3000 "The SSID element indicates the identity of an ESS or IBSS." 

3001 return self._get_element(DOT11_MANAGEMENT_ELEMENTS.SSID) 

3002 

3003 def set_ssid(self, ssid): 

3004 self._set_element(DOT11_MANAGEMENT_ELEMENTS.SSID,ssid) 

3005 

3006 def get_supported_rates(self, human_readable=False): 

3007 "Get the 802.11 Management Supported Rates element. "\ 

3008 "Specifies up to eight rates, then an Extended Supported Rate element "\ 

3009 "shall be generated to specify the remaining supported rates."\ 

3010 "If human_readable is True, the rates are returned in Mbit/sec" 

3011 s=self._get_element(DOT11_MANAGEMENT_ELEMENTS.SUPPORTED_RATES) 

3012 if s is None: 3012 ↛ 3013line 3012 didn't jump to line 3013, because the condition on line 3012 was never true

3013 return None 

3014 

3015 rates=struct.unpack('%dB'%len(s),s) 

3016 if not human_readable: 

3017 return rates 

3018 

3019 rates_Mbs=tuple([(x&0x7F)*0.5 for x in rates]) 

3020 return rates_Mbs 

3021 

3022 def set_supported_rates(self, rates): 

3023 "Set the 802.11 Management Supported Rates element. "\ 

3024 "Specifies a tuple or list with up to eight rates, then an "\ 

3025 "Extended Supported Rate element shall be generated to specify "\ 

3026 "the remaining supported rates." 

3027 qty_rates=len(rates) 

3028 if qty_rates>8: 3028 ↛ 3029line 3028 didn't jump to line 3029, because the condition on line 3028 was never true

3029 raise Exception("requires up to eight rates") 

3030 rates_string=struct.pack('B'*qty_rates,*rates) 

3031 self._set_element(DOT11_MANAGEMENT_ELEMENTS.SUPPORTED_RATES,rates_string) 

3032 

3033 def get_rsn(self): 

3034 "Get the 802.11 Management Robust Security Network element." 

3035 s = self._get_element(DOT11_MANAGEMENT_ELEMENTS.RSN) 

3036 if s is None: 3036 ↛ 3037line 3036 didn't jump to line 3037, because the condition on line 3036 was never true

3037 return None 

3038 return s 

3039 

3040 def set_rsn(self, data): 

3041 "Set the 802.11 Management Robust Security Network element." 

3042 self._set_element(DOT11_MANAGEMENT_ELEMENTS.RSN, data) 

3043 

3044 def get_vendor_specific(self): 

3045 "Get the 802.11 Management Vendor Specific elements "\ 

3046 "as a list of tuples." 

3047 "The Vendor Specific information element is used to carry "\ 

3048 "information not defined in the standard within a single "\ 

3049 "defined format" 

3050 

3051 vs=[] 

3052 gen_get_element=self._get_elements_generator(DOT11_MANAGEMENT_ELEMENTS.VENDOR_SPECIFIC) 

3053 try: 

3054 while 1: 

3055 s=next(gen_get_element) 

3056 

3057 if s is None: 3057 ↛ 3058line 3057 didn't jump to line 3058, because the condition on line 3057 was never true

3058 raise Exception("gen_get_element salio con None!!!") 

3059 

3060 # OUI is 3 bytes 

3061 oui=s[:3] 

3062 data=s[3:] 

3063 vs.append((oui,data)) 

3064 except StopIteration: 

3065 pass 

3066 

3067 return vs 

3068 

3069 def add_vendor_specific(self, oui, data): 

3070 "Set the 802.11 Management Vendor Specific element. "\ 

3071 "The Vendor Specific information element is used to carry "\ 

3072 "information not defined in the standard within a single "\ 

3073 "defined format" 

3074 

3075 # 3 is the OUI length 

3076 max_data_len=255-3 

3077 data_len=len(data) 

3078 

3079 if data_len>max_data_len: 3079 ↛ 3080line 3079 didn't jump to line 3080, because the condition on line 3079 was never true

3080 raise Exception("data allow up to %d bytes long" % max_data_len) 

3081 if len(oui) > 3: 3081 ↛ 3082line 3081 didn't jump to line 3082, because the condition on line 3081 was never true

3082 raise Exception("oui is three bytes long") 

3083 

3084 self._set_element(DOT11_MANAGEMENT_ELEMENTS.VENDOR_SPECIFIC,oui+data, replace=False) 

3085 

3086class Dot11ManagementReassociationResponse(Dot11ManagementAssociationResponse): 

3087 '802.11 Management Reassociation Response Frame' 

3088 

3089 def __init__(self, aBuffer = None): 

3090 Dot11ManagementAssociationResponse.__init__(self, aBuffer)