def connect(self, ssid, timeout=120, authentication="", encryption="", key="", key_index=1): """ 按照指定的ssid及其加密模式连接无线AP """ key_index = int(key_index) timeout = int(timeout) if timeout <= 0: log_data = u'timout<=0,请设置>0的值。' log.user_err(log_data) raise RuntimeError(log_data) if self.obj.connect(ssid, timeout=timeout, authentication=authentication, encryption=encryption, key=key, keyIndex=key_index) == WLAN_OK: log_data = u'无线网卡连接成功' log.user_info(log_data) else: log_data = u'连接失败。' raise RuntimeError(log_data)
def _check_input_str_unicode(self, str_or_unicode): """ 函数功能:检查输入的参数是不是str或者unicode,并去掉前后的空格 参数: str_or_unicode 字符串 返回值: str_or_unicode 经过转换后的字符串 """ err_data = "" if isinstance(str_or_unicode, str) or\ isinstance(str_or_unicode, unicode): str_or_unicode = str_or_unicode.strip() if str_or_unicode: str_or_unicode = str_or_unicode.lower() else: err_data = u"输入的信息格式 %s 不合法!" % str_or_unicode if err_data: log.user_err(err_data) raise RuntimeError(err_data) return str_or_unicode
def query_wlan_show_interface(self, key): """ 根据需求获取无线接口信息参数; """ result = self._exec_cmd('netsh wlan show interface') result = result.decode(sys.getfilesystemencoding()) result = result.split("\r\n") # 将获取的信息转换为标准的列表格式 if u'已连接' in result[7]: result = result[3:20] list_result = [] for i in result: tmp = i.replace(' ', '') list_result.append(tmp) # 将获取的信息已字典格式存储 dict_result = {} for var in list_result: tmp_key = var.split(':', 1)[0] tmp_value = var.split(':', 1)[1] dict_result.update({tmp_key: tmp_value}) # 判断key是否存在 if dict_result.has_key(key): return dict_result[key] else: log_data = u'输入的无线接口信息参数不存在' log.user_err(log_data) raise RuntimeError(log_data) elif u'已断开连接' in result[7]: log_data = u'当前无线网卡状态是已断开连接' log.user_err(log_data) raise RuntimeError(log_data)
def switch_ping_site(self, alias): """ 功能描述:切换当前ping操作所在的主机 参数:alias,别名 返回值:无 Example: | Init Ping Site | 1 | | Should Ping Ipv4 Success By Count | 192.168.1.1 | 4 | | Init Ping Site | 2 | 10.10.10.84 | | Should Ping Ipv4 Fail By Count | 192.168.1.1 | 4 | | Switch Ping Site | 1 | | Should Ping Ipv4 Success By Time | 192.168.1.1 | 10 | | Switch Ping Site | 2 | | Should Ping Ipv4 Fail By Time | 192.168.1.1 | 4 | """ try: cls = self._cache.switch(alias) if (isinstance(cls, Remote)): # remote class do switch auto_do_remote(cls) else: log_data = u'成功切换到别名为:%s 的主机下,后续Ping操作都是针对该主机,直到下一个初始化或切换动作' % alias log.user_info(log_data) except (RuntimeError, DataError): # RF 2.6 uses RE, earlier DE log_data = "No remotelocal with alias '%s' found." % alias log.user_err(log_data) raise RuntimeError(log_data)
def auto_connect(self, ssid, timeout=120, key="", key_index=1): """ """ # if self.obj.delete_profile(ssid) == WLAN_OK: log_data = u'删除名称为 %s 的无线Profile成功' % ssid log.user_info(log_data) else: log_data = u'删除名称为 %s 的无线Profile失败' % ssid log.user_err(log_data) # s = self.query_security_info(ssid) authentication = "" encryption = "" t = self._security_convert(s) authentication = t[0] encryption = t[1] log_data = u"采用连接模式:authentication=%s, encryption=%s" % ( authentication, encryption) log.user_info(log_data) if self.obj.connect(ssid, timeout, authentication, encryption, key, key_index) == WLAN_OK: log_data = u'无线网卡连接成功' log.user_info(log_data) else: log_data = u'连接失败。' raise RuntimeError(log_data)
def start_library(library_name=""): try: RobotRemoteServer(ATTInterfaceUnit()) return None except Exception, e: log_data = "start %s library fail!\n message:%s" % (library_name, e) log.user_err(log_data) raise RuntimeError(log_data)
def ssid_should_not_in_available_network_list(self, ssid): """无线SSID应在可用的无线网络列表中查询不到""" if ssid not in self.get_available_network_list(): log_data = u'SSID %s 不在当前可用的无线网络列表中' % ssid log.user_info(log_data) else: log_data = u'SSID %s 在当前可用的无线网络列表中' % ssid log.user_err(log_data) raise RuntimeError(log_data)
def should_be_connected(self): """无线网卡当前应处于连接状态""" if self.query_interface_status() == 'wlan_interface_state_connected': log_data = u'当前无线网卡处于连接状态' log.user_info(log_data) else: log_data = u'当前无线网卡没有连接成功' log.user_err(log_data) raise RuntimeError(log_data)
def wireshark_capture_success(self, flag_pid): """ 功能描述: 成功抓到报文关键字执行成功,报文为空,关键字执行失败 参数: flag_pid: Start WireShark 关键字执行成功后的返回值 """ ret = WIRESHARK_FAIL str_data = "" dict_data = self.dict_process_obj.get(flag_pid) if dict_data: popen = dict_data.get("popen") file_path = dict_data.get("temp_packet_file_path") obj_parse_pcap = dict_data.get("obj_parse_pcap") if popen and popen.poll() == None: if dict_data.get("flag_2_stop"): err_data = u"停止抓包服务器失败,判断 %s 服务器成功与否失败!" % flag_pid raise RuntimeError(err_data) else: dict_data["flag_2_stop"] = True self.dict_process_obj.update({flag_pid: dict_data}) ret = WIRESHARK_NO_STOP return ret if file_path is None: str_data = u"获取 %s 相应的抓包文件失败!" % flag_pid elif os.path.exists(file_path): if not obj_parse_pcap: obj_parse_pcap = ParsePcapFile(self.wireshark_install_path, file_path) dict_data["obj_parse_pcap"] = obj_parse_pcap self.dict_process_obj.update({flag_pid: dict_data}) else: obj_parse_pcap = dict_data.get("obj_parse_pcap") if obj_parse_pcap.check_file_empty( file_path) != PARSE_PCAP_FILE_F: ret = WIRESHARK_SUCCESS str_data = u"成功捕获到报文" else: str_data = u"捕获到报文为空" else: str_data = u"捕获到报文为空" else: str_data = u"%s 相应抓包服务器不存在,不能判定成功捕获到报文!" % flag_pid if ret == WIRESHARK_FAIL: log.user_err(str_data) raise RuntimeError(str_data) else: log.user_info(str_data)
def ssid_should_in_available_network_list(self, ssid): """无线SSID应在可用的无线网络列表中可以查询到""" check_status = 0 if ssid in self.get_available_network_list(): log_data = u'SSID %s 在当前可用的无线网络列表中' % ssid log.user_info(log_data) else: log_data = u'SSID %s 不在当前可用的无线网络列表中' % ssid log.user_err(log_data) raise RuntimeError(log_data)
def delete_profile(self, ssid): """ 删除指定SSID的profile。 """ if self.obj.delete_profile(ssid) == WLAN_OK: log_data = u'删除名称为 %s 的无线Profile成功' % ssid log.user_info(log_data) else: log_data = u'删除名称为 %s 的无线Profile失败' % ssid log.user_err(log_data) raise RuntimeError(log_data)
def delete_all_profile(self): """ 删除所有profile。 """ if self.obj.delete_all_profile() == WLAN_OK: log_data = u'删除所有profile成功' log.user_info(log_data) else: log_data = u'删除所有无线Profile失败' log.user_err(log_data) raise RuntimeError(log_data)
def query_interface_status(self): """ 查询并返回当前无线网卡状态。 """ if self.obj.query_interface_status() == WLAN_OK: interface_status = self.obj.get_return() if interface_status[:1] == '{' and interface_status[-1:] == '}': interface_status = interface_status[1:-1] return interface_status else: log_data = u'查询网卡状态失败' log.user_err(log_data) raise RuntimeError(log_data)
def get_available_network_list(self): """ 查询可用的无线网络连接,返回可用的无线网络列表。 """ ret = self.obj.get_available_network_list() if ret != WLAN_OK: log_data = u'查询可用的无线网络连接失败。' log.user_err(log_data) raise RuntimeError(log_data) else: #return self.obj.get_desc().decode(sys.getfilesystemencoding()).split('\n') # default unicode return self.obj.get_return().split('\n')
def telnet_close_all_connections(self): """ 功能描述:关闭所有打开的telnet连接,包括本端和远端所有打开的telnet连接 参数: 无; 返回值: 无; 备注: 此关键字常用于拆除里面作清理操作,对所有已打开的telnet连接进行关闭,如果打开连接失败 再在拆除里面执行此关键字,此关键字也会报关闭已打开的所有telnet连接成功; Example: | Init Telnet Connection | local | 192.168.1.1 | | Telnet Open Connection | 23 | 3 | > | | Telnet Login | admin | admin | | Init Telnet Connection | remote | 192.168.1.1 | http://172.16.28.55 | | Telnet Open Connection | 23 | 3 | > | | Telnet Login | admin | admin | | Switch Telnet Connection | local | | Telnet Execute Command | help | | Switch Telnet Connection | remote | | Telnet Execute Command | ps | | Telnet Close All Connections | """ # 重新封装telnet_close_all_connections函数,增加log输出,方便用户查看 lwb:2013-05-02 if 0 == len(self.list_cls_remote) and 0 == len(self.list_cls_local): return # 判断有没有远端实例 lwb: 2013-04-20 for cls in self.list_cls_remote: if (isinstance(cls, Remote)): auto_do_remote(cls) # 关闭所有打开的连接,如果list_cls_local列表中没有数据,就不进行关闭 lwb: 2013-04-22 for cls in self.list_cls_local: cls.telnet_close_all_connections() # 如果只有本端,则在本端进行log输出 lwb:2013-05-02 if len(self.list_cls_remote) > 0: pass elif len(self.list_cls_remote) == 0 and len(self.list_cls_local) > 0: log_data = u"关闭所有telnet连接,包括本端和远端" log.user_err(log_data)
def _check_wireshark_stop(self, flag_pid): """ """ cls = self._current_remotelocal() dict_data = cls.dict_capture_obj.get(flag_pid) if not dict_data: err_data = u"没有找到相应抓包服务器" log.user_err(err_data) raise RuntimeError(err_data) elif dict_data.get("flag_stop"): return True else: return False
def ssid_connect_by_none(self, ssid, timeout=120): """采用不加密模式连接SSID(只下发连接命令,不关注连接结果)。""" timeout = int(timeout) if timeout <= 0: log_data = u'timout<=0,请设置>0的值。' log.user_err(log_data) raise RuntimeError(log_data) if self.obj.connect(ssid, timeout=timeout, authentication='open', encryption='none') == WLAN_OK: log_data = u'无线网卡采用不加密模式连接SSID %s 连接成功。' % ssid else: log_data = u'无线网卡采用不加密模式连接SSID %s 连接失败。' % ssid log.user_info(log_data)
def ssid_should_connect_by_none_fail(self, ssid, timeout=120): """采用不加密模式连接SSID,应连接不成功。""" timeout = int(timeout) if timeout <= 0: log_data = u'timout<=0,请设置>0的值。' log.user_err(log_data) raise RuntimeError(log_data) if self.obj.connect( ssid, timeout=timeout, authentication='open', encryption='none') != WLAN_OK: log_data = u'无线网卡采用不加密模式连接SSID %s 应该连接失败,实际连接失败。' % ssid log.user_info(log_data) else: log_data = u'无线网卡采用不加密模式连接SSID %s 应该连接失败,实际连接成功。' % ssid log.user_err(log_data) raise RuntimeError(log_data)
def ssid_connect_by_WPA2_PSK_TKIP(self, ssid, key, timeout=120): """采用WPA2_PSK_TKIP模式连接SSID(只下发连接命令,不关注连接结果)。""" timeout = int(timeout) if timeout <= 0: log_data = u'timout<=0,请设置>0的值。' log.user_err(log_data) raise RuntimeError(log_data) if self.obj.connect(ssid, timeout=timeout, authentication='WPA2PSK', encryption='TKIP', key=key) == WLAN_OK: log_data = u'无线网卡采用WPA2_PSK_TKIP模式连接SSID %s 连接成功。' % ssid else: log_data = u'无线网卡采用WPA2_PSK_TKIP模式连接SSID %s 连接失败。' % ssid log.user_info(log_data)
def ssid_should_connect_by_WPA2_PSK_AES_fail(self, ssid, key, timeout=120): """采用WPA2_PSK_AES模式连接SSID,应连接不成功。""" timeout = int(timeout) if timeout <= 0: log_data = u'timout<=0,请设置>0的值。' log.user_err(log_data) raise RuntimeError(log_data) if self.obj.connect(ssid, timeout=timeout, authentication='WPA2PSK', encryption='AES', key=key) != WLAN_OK: log_data = u'无线网卡采用WPA2_PSK_AES模式连接SSID %s 应该连接失败,实际连接失败。' % ssid log.user_info(log_data) else: log_data = u'无线网卡采用WPA2_PSK_AES模式连接SSID %s 应该连接失败,实际连接成功。' % ssid log.user_err(log_data) raise RuntimeError(log_data)
def ssid_connect_by_open_wep(self, ssid, key, key_index=1, timeout=120): """采用open wep模式连接SSID(只下发连接命令,不关注连接结果)。""" key_index = int(key_index) timeout = int(timeout) if timeout <= 0: log_data = u'timout<=0,请设置>0的值。' log.user_err(log_data) raise RuntimeError(log_data) if self.obj.connect(ssid, timeout=timeout, authentication='open', encryption='WEP', key=key, keyIndex=key_index) == WLAN_OK: log_data = u'无线网卡采用open wep模式连接SSID %s 连接成功。' % ssid else: log_data = u'无线网卡采用open wep模式连接SSID %s 连接失败。' % ssid log.user_info(log_data)
def _pingprocess_by_time(self, ip_url, total_time = 3600, psize = 32): """子进程中持续ping,ICMP包长默认为32,默认时间为3600秒""" if psize == "": psize = 32 if total_time == "": total_time = 3600 psize,count,total_time = self._check_ping_para(psize,None,total_time) ret = PING_SUCCESS counter = 0 for i in [1]: try: pid = PingProcess(node=ip_url, total_time = total_time, size=psize) pid.start() except Exception, e: err_info = "Starting PingProcess Error:%s" % e ret_data = err_info log.user_err(ret_data) ret = PING_FAIL break # 修改偶现长时间临时文件生成失败的问题,这里延长等待时间 # modify by shenlige 2014-1-13 while not isfile(pid.get_ping_tmp_file()) and counter < 120: # 等待ping文件正常生成,这里默认等待15秒,若超过15秒则报错退出 modify by shenlige 2013-4-9 time.sleep(1) counter += 1 if counter >= 120: ret_data = u"等待120s后,进程执行ping还是存在异常,请确认" log.user_err(ret_data) ret = PING_FAIL break # wait a moment to check whether the ping pid is ok if not pid.is_alive: ret_data = pid.err_info ret = PING_FAIL
def disconnect(self): """ 断开无线网卡连接。 """ # Change by jxy 2013/3/15 断开连接之后,增加查询无线网卡状态,如果状态不是断开状态,重复三次。 i = 0 while i < 3: i += 1 try: nret = self.obj.disconnect() time.sleep(3) status = self.query_interface_status() if status == 'wlan_interface_state_disconnected': log_data = u'断开无线网卡连接成功' log.user_info(log_data) break except Exception, e: log_data = u"多次断开无线网卡连接失败。错误信息如下:%s" % e log.user_err(log_data) raise RuntimeError(log_data)
def _check_extension(self, file_name): """ 函数功能:检查输入的文件名称是否是正确的扩展名pcap 参数: file_name 文件名称 返回值: pcap_file 返回正确的pcap路径 """ err_data = "" file_extension = os.path.split(file_name)[1] if ".pcap" in file_extension: pcap_file = file_name else: err_data = u"输入的信息格式 %s 不合法!" % file_name if err_data: log.user_err(err_data) raise RuntimeError(err_data) return pcap_file
def pingNode(node,number=5,size=ICMP_DATA_STR,total_time=None): """ 功能描述:ping接口 """ ret = PING_SUCCESS counter = 0 for i in [1]: try: if not exists(ATTROBOT_TEMP_FILE_PAHT): os.makedirs(ATTROBOT_TEMP_FILE_PAHT) PING_TMP_FILE = os.path.join(ATTROBOT_TEMP_FILE_PAHT,"ping_temp_file.txt") except Exception,e: log_data = u"生成平台的临时目录发生错误: %s" % e raise RuntimeError(log_data) try: # 修改可执行文件路径 modify by shenlige 2013-5-22 # 默认使用ping次数 if total_time: number = 2592000 cmd_smg = " -l %s -n %s %s" % (size,number,node) cmd = "\"" + EXE_PATH + "\"" + cmd_smg with open(PING_TMP_FILE,"w") as file_tmp: popen = subprocess.Popen(cmd,shell=True, stdin=subprocess.PIPE, stdout=file_tmp, stderr=subprocess.PIPE) except Exception, e: log_data = u"执行ping.exe发生异常,message:%s" % e log.user_err(log_data) ret = PING_FAIL break
def ssid_should_connect_by_shared_wep_success(self, ssid, key, key_index=1, timeout=120): """采用shared wep模式连接SSID,应连接成功。""" key_index = int(key_index) timeout = int(timeout) if timeout <= 0: log_data = u'timout<=0,请设置>0的值。' log.user_err(log_data) raise RuntimeError(log_data) if self.obj.connect(ssid, timeout=timeout, authentication='shared', encryption='WEP', key=key, keyIndex=key_index) == WLAN_OK: log_data = u'无线网卡采用shared wep模式连接SSID %s 应该连接成功,实际连接成功。' % ssid log.user_info(log_data) else: log_data = u'无线网卡采用shared wep模式连接SSID %s 应该连接成功,实际连接失败。' % ssid log.user_err(log_data) raise RuntimeError(log_data)
def ssid_should_connect_by_open_wep_fail(self, ssid, key, key_index=1, timeout=120): """采用open wep模式连接SSID,应连接不成功。""" timeout = int(timeout) if timeout <= 0: log_data = u'timout<=0,请设置>0的值。' log.user_err(log_data) raise RuntimeError(log_data) key_index = int(key_index) if self.obj.connect(ssid, timeout=timeout, authentication='open', encryption='WEP', key=key, keyIndex=key_index) != WLAN_OK: log_data = u'无线网卡采用open wep模式连接SSID %s 应该连接失败,实际连接失败。' % ssid log.user_info(log_data) else: log_data = u'无线网卡采用open wep模式连接SSID %s 应该连接失败,实际连接成功。' % ssid log.user_err(log_data) raise RuntimeError(log_data)
ret = cls.get_nic_name_or_mac(name_or_mac) return ret def start_library(host="172.0.0.1", port=REMOTE_PORT, library_name=""): try: log.start_remote_process_log(library_name) except ImportError, e: raise RuntimeError(u"创建log模块失败,失败信息:%" % e) try: RobotRemoteServer(NetConfig(), host, port) return None except Exception, e: log_data = "start %s library fail!\n message:%s" % (library_name, e) log.user_err(log_data) raise RuntimeError(log_data) def test(): cls1 = NetConfig() cls1.init_nic_card("1", u"办公网") cls1.get_nic_ipv4_address() cls1.init_nic_card("1", u"本地连接 2", "http://10.10.10.6:58007") cls1.get_nic_ipv4_address() ''' #cls1.get_ip_by_mac("44-37-E6-99-46-C1") #cls1.get_ip_by_mac("00-19-E0-03-20-C3") cls1.open_netconfig_remotelocal("local") cls1.get_ip_by_mac(mac_address="00-1A-A0-C0-0F-96")
class WireShark(): ROBOT_LIBRARY_SCOPE = 'GLOBAL' ROBOT_LIBRARY_VERSION = VERSION def __init__(self): self._cache = ConnectionCache() self.dict_alias = {} self.flag_stop_all = False self.dict_all_capture_pid_and_cls = {} # 保存所有启动的抓包服务器的pid和cls def _register_alias(self, alias, name, mac_address, remote_url): # 对别名判断做了修改 zsj 2013-3-28 # 改成以别名为健(当前要求别名唯一) change by yzm @ 20130328 # 因前面已经保证了alias唯一,则直接对alias进行赋值(赋新值可保证网卡信息为最新的信息) self.dict_alias[alias] = ((name, mac_address), remote_url) def _is_init(self, name_or_mac, remote_url, alias): """ return alias """ # 先判断别名是否被使用过 _value = self.dict_alias.get(alias) if _value: # 如果被使用过,需要判断是否被当前对象使用(相同的remote_url以及name或者mac) if remote_url in _value and name_or_mac in _value[0]: # 如果相符,则可以直接返回alias return alias else: raise RuntimeError(u"别名 %s 正在被另外的对象使用,请选择另外的别名!" % alias) else: # 如果没被使用过,需判断当前的对象是否曾经被初始化过 for key, tuple_value in self.dict_alias.items(): if remote_url in tuple_value and name_or_mac in tuple_value[0]: # 如果相符,则可以直接返回_key(只要找到即可返回) return key # 两种情况都不包含,则返回None return None def init_wireshark_network_card(self, alias, name_or_mac, remote_url=False): """ 功能描述:初始化网卡,为网卡配置别名; 参数: alias:别名\n name_or_mac:网卡名称或者是MAC地址\n remote_url:是否要进行远程控制。(默认不进行远程)。\n remote_url格式为:http://remote_IP.可以用以下的几种方式进行初始化。注意别名请设置为 不同的别名,切换的时候用别名进行切换。 返回值:无 Example: | Init WireShark Network Card | One | 本地连接1 | | Init WireShark Network Card | two | 本地连接1 | http://10.10.10.84 | | Init WireShark Network Card | 3 | 44-37-E6-99-7C-B9 | | Init WireShark Network Card | 4 | 44:37:E6:99:7C:B9 | """ # 输入的name_or_mac做转换,除去格式的差异 name_or_mac = modified_name_or_mac(name_or_mac) # 对用户输入的remote_url做处理转换,添加http://头等 remote_url = modified_remote_url(remote_url) if (is_remote(remote_url)): # already init? ret_alias = self._is_init(name_or_mac, remote_url, alias) if (ret_alias): reallib = self._cache.switch(ret_alias) else: reallib = Remote(remote_url) reallib._client.set_timeout( REMOTE_TIMEOUT) # add connection remote timeout zsj 2013-3-28 network_name, network_mac = auto_do_remote(reallib) else: # already init? ret_alias = self._is_init(name_or_mac, remote_url, alias) if (ret_alias): reallib = self._cache.switch(ret_alias) else: reallib = ATTWireShark(name_or_mac) network_name = reallib.get_network_name() network_mac = reallib.get_network_mac() tag = self._cache.register(reallib, alias) self._register_alias(alias, network_name, network_mac, remote_url) return network_name, network_mac def _current_remotelocal(self): if not self._cache.current: raise RuntimeError('No remotelocal is open') return self._cache.current def switch_wireshark_network_card(self, alias): """ 功能描述:使用alias在当前已存在的网卡对象中进行切换 参数:alias,别名。 返回值:无 Example: | Init WireShark Network Card | 1 | 本地连接1 | | Init WireShark Network Card | 2 | 本地连接1 | http://10.10.10.84 | | Switch WireShark Network Card | 1 | | Switch WireShark Network Card | 2 | """ try: cls = self._cache.switch(alias) if (isinstance(cls, Remote)): # remote class do switch auto_do_remote(cls) else: log_data = u'成功切换到别名为:%s 的网卡下,后续抓包操作都是针对该网卡,直到下一个切换动作' % alias log.user_info(log_data) except (RuntimeError, DataError): # RF 2.6 uses RE, earlier DE raise RuntimeError("No remotelocal with alias '%s' found." % alias) def set_wireshark_install_path(self, file_path): """ 功能描述:设置抓包电脑上wireshark的安装路径;\n 参数:\n file_path: wireshark软件的安装路径 Example: | Set Wireshark Install Path | c:\\\\Program Files\\\\WireShark | """ cls = self._current_remotelocal() if (isinstance(cls, Remote)): auto_do_remote(cls) else: cls.set_wireshark_install_path(file_path) def start_wireshark_capture(self, capture_filter="", prefix="ATT", file_path="default"): """ 功能描述: 开始当前网卡设备的抓包 参数:\n capture_filter: 抓包过滤器表达式,不下发表示抓取所有包\n\n perfix: 保存抓包文件的前缀\n file_path: 保存抓包文件的路径\n 返回值:\n flag_pid: 启动成功返回进程标识 Example: | ${flag_pid1} | Start WireShark Capture | | ATT | | ${flag_pid2} | Start WireShark Capture | tcp | ATT | | ${flag_pid3} | Start WireShark Capture | tcp | ATT | c:\\\\wireshark | """ if IS_LOCAL: self._check_prefix(prefix) cls = self._current_remotelocal() if (isinstance(cls, Remote)): ret = auto_do_remote(cls) else: ret = cls.start_wireshark_capture(capture_filter, prefix, file_path) self.dict_all_capture_pid_and_cls.update({ret: cls}) return ret def get_wireshark_flag_pid(self, pcap_file): """ 功能描述: 获取已抓到数据报文flag_pid 参数:\n pcap_file: 已抓到数据报文的路径\n 返回值:\n flag_pid: 启动成功返回进程标识 Example: | ${flag_pid} | Get WireShark Flag Pid | D:\\\\capture | """ ret = None cls = self._current_remotelocal() if (isinstance(cls, Remote)): ret = auto_do_remote(cls) else: ret = cls.get_wireshark_flag_pid(pcap_file) self.dict_all_capture_pid_and_cls.update({ret: cls}) return ret def stop_wireshark_capture(self, flag_pid): """ 功能描述: 停止当前网卡设备的抓包 参数:\n flag_pid: Start WireShark Capture关键字执行成功后的返回值 返回值:无 *注意:flag_pid传入为空或者None时不进行关闭动作。 Example: | ${flag_pid} | Start WireShark Capture | | ATT | | Stop WireShark Capture | ${flag_pid} | """ # 当同时开启多个抓包的时候会有抓不到包的情况,如果加1s延时效果好点 zsj2013/12/23 if not self.flag_stop_all: time.sleep(1) cls = self.dict_all_capture_pid_and_cls.get(flag_pid) if not cls: str_warn = u"没有找到相应抓包服务器%s" % flag_pid log.user_warn(str_warn) return if (isinstance(cls, Remote)): ret, ret_data = auto_do_remote(cls) else: ret, ret_data = cls.stop_wireshark_capture(flag_pid) if not IS_LOCAL: # 如果是如果不运行后面的保存文件等,直接返回 return ret, ret_data # 根据停止返回的数据保存抓包文件 if ret == WIRESHARK_SUCCESS: self._save_pcap_file_and_link_file(ret_data) # 删除已关闭的抓包服务器的存储 if self.dict_all_capture_pid_and_cls.get(flag_pid): self.dict_all_capture_pid_and_cls.pop(flag_pid) def wireshark_query_option_str_value(self, flag_pid, option_name_or_offset, read_filter=""): """ 功能描述: 查询抓到数据包中某个字段的值 参数:\n flag_pid: Start WireShark Capture关键字执行成功后的返回值\n option_name_or_offset: 所要查询的字段名\n read_filter: 读取过滤器表达式\n 返回值:\n list_data: 查询成功返回列表形式option_name字段值或None Example: | ${list_data} | Wireshark Query Option Str Value | ${flag_pid} | ip.version | tcp | | ${list_data} | Wireshark Query Option Str Value | ${flag_pid} | frame[58:34] | tcp | """ ret = None cls = self._current_remotelocal() if (isinstance(cls, Remote)): ret = auto_do_remote(cls) else: ret = cls.wireshark_query_option_str_value(flag_pid, option_name_or_offset, read_filter) if IS_LOCAL and ret == WIRESHARK_NO_STOP: str_data = u"抓包服务器未停止,开始自动停止抓包服务器!" log.user_warn(str_data) self.stop_wireshark_capture(flag_pid) ret = self.wireshark_query_option_str_value( flag_pid, option_name_or_offset, read_filter) else: pass return ret def wireshark_query_option_byte_value(self, flag_pid, option_name_or_offset, read_filter=""): """ 功能描述: 查询抓到数据包中某个字段的十六进制值。 参数:\n flag_pid: Start WireShark Capture关键字执行成功后的返回值\n option_name_or_offset: 所要查询的字段名\n read_filter: 读取过滤器表达式\n 返回值:\n list_data: 查询成功返回列表形式option_name字段值或None Example: | ${list_data} | Wireshark Query Option Byte Value | ${flag_pid} | ip.version | tcp | | ${list_data} | Wireshark Query Option Byte Value | ${flag_pid} | frame[58:34] | tcp | """ ret = None cls = self._current_remotelocal() if (isinstance(cls, Remote)): ret = auto_do_remote(cls) else: ret = cls.wireshark_query_option_byte_value( flag_pid, option_name_or_offset, read_filter) if IS_LOCAL and ret == WIRESHARK_NO_STOP: str_data = u"抓包服务器未停止,开始自动停止抓包服务器!" log.user_warn(str_data) self.stop_wireshark_capture(flag_pid) ret = self.wireshark_query_option_byte_value( flag_pid, option_name_or_offset, read_filter) else: pass return ret def stop_all_wireshark_capture(self): """ 功能描述: 关闭所有开启的抓包浏览器并保存.\n 参数:无 返回值:无 Example: | Init WireShark Network Card | One | 本地连接1 | | ${flag_pid1} | Start WireShark Capture | | ATT | | ${flag_pid2} | Start WireShark Capture | tcp | ATT | | ${flag_pid3} | Start WireShark Capture | tcp | ATT | c:\\\\wireshark | | Stop All WireShark Capture | """ # 当同时开启多个抓包的时候会有抓不到包的情况,如果加2s延时效果好点 zsj2013/12/23 time.sleep(2) self.flag_stop_all = True for flag_pid in self.dict_all_capture_pid_and_cls.keys(): try: self.stop_wireshark_capture(flag_pid) except: pass self.flag_stop_all = False def wireshark_capture_packet_success(self, flag_pid): """ 功能描述: 成功抓到报文关键字执行成功,报文为空,关键字执行失败.\n 参数:\n flag_pid: Start WireShark Capture关键字执行成功后的返回值 返回值:无 Example: | Wireshark Capture Packet Success | ${flag_pid} | """ ret = None cls = self._current_remotelocal() if (isinstance(cls, Remote)): ret = auto_do_remote(cls) else: ret = cls.wireshark_capture_success(flag_pid) if IS_LOCAL and ret == WIRESHARK_NO_STOP: str_data = u"抓包服务器未停止,开始自动停止抓包服务器!" log.user_warn(str_data) self.stop_wireshark_capture(flag_pid) self.wireshark_capture_packet_success(flag_pid) else: return ret def _save_pcap_file_and_link_file(self, tuple_data): """ """ ret = FLAG_SUCCEED packet_data = tuple_data[0] if packet_data is None: # 如果停止的时候没有找到数据文件,返回成功 return ret ret, str_data = self._get_packet_file_path(tuple_data[1]) if ret == FLAG_SUCCEED: file_path = str_data try: with open(file_path, "wb") as obj_file2: obj_file2.write(base64.b64decode(packet_data)) str_data = u"保存抓包数据到指定路径 %s 成功!" % file_path self._link_wireshark_file(file_path) except Exception, e: ret = FLAG_FAIL str_data = "%s" % e if ret == FLAG_SUCCEED: log.user_info(str_data) else: err_data = u"把抓包文件保存到用户指定文件错误,错误信息:%s" % str_data log.user_err(err_data)
dict_data["file_path"] = file_path dict_data["temp_packet_file_path"] = temp_packet_file_path dict_data["popen_stdout_path"] = popen_stdout_path self.dict_process_obj.update({flag_pid: dict_data}) cmd_pid_with_tshark_path = os.path.join(ATTROBOT_TEMP_FILE_PAHT, "cmd_pid_with_tshark.txt") try: with open(cmd_pid_with_tshark_path, "a+") as file_obj: file_obj.write("%s\n" % popen.pid) except Exception, e: debug_msg = u"保存抓包服务器flag_pid=%s失败,该服务器不能自动关闭" % popen.pid log.debug_warn(debug_msg) else: log.user_err(ret_data) raise RuntimeError(ret_data) return flag_pid def get_wireshark_flag_pid(self, pcap_file): """ 功能描述: 获取已抓到数据报文flag_pid 参数:\n pcap_file: 已抓到数据报文的路径\n """ if not self.wireshark_install_path: self.wireshark_install_path = self._get_default_install_path()