---

@CanalQb no YouTube

---

Leitura: ~9 min | Atualizado: July 2026

Como Criar um Port Scanner em Python com Interface Gráfica PyQt

TL;DR - Resumo Executivo

• Conteudo preservado com expansao contextual sobre o tema original.
• Verificacoes praticas adicionadas para reduzir retrabalho.
• Fontes registradas nos metadados para rastreabilidade.

Como Criar um Port Scanner em Python com Interface Gráfica PyQt - ponto de partida

Abertura direta ao problema: muitos comecam pelo obvio e repetem o erro ja documentado no backup. Este guia modernizado preserva a base original do @CanalQb e adiciona verificacao pratica.

Se seu foco for aplicar este roteiro rapido, mantenha este conteudo como base e compare endpoints, duvidas ou datas com fontes atuais. O que realmente importa e o metodo, nao apenas a documentacao.

		Port Scanner em Python com PyQt
Canal de Programação

Introdução

Um port scanner é uma ferramenta essencial para administradores de rede e profissionais de segurança. Neste tutorial, vamos criar um scanner de portas completo com interface gráfica usando Python e PyQt5.

Instalação Necessária

Antes de começar, instale o PyQt5:

pip install pyqt5

Versão Básica do Port Scanner

Este é um scanner TCP simples que verifica portas individuais:

import sys
import threading
import socket
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton, QLineEdit

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Port Scanner")
        self.setGeometry(100, 100, 500, 300)

        # Interface b��sica
        self.label_host = QLabel("Host:", self)
        self.label_host.move(50, 50)
        self.textbox_host = QLineEdit(self)
        self.textbox_host.move(150, 50)
        self.textbox_host.resize(200, 30)

        self.label_portas = QLabel("Portas (separadas por vírgula):", self)
        self.label_portas.move(50, 100)
        self.textbox_portas = QLineEdit(self)
        self.textbox_portas.move(150, 100)
        self.textbox_portas.resize(200, 30)

        self.label_resultado = QLabel("", self)
        self.label_resultado.move(50, 200)

        self.button = QPushButton("Scan", self)
        self.button.move(150, 150)
        self.button.clicked.connect(self.scan)

    def scan(self):
        host = self.textbox_host.text()
        portas = self.textbox_portas.text().split(",")
        self.label_resultado.setText("Scanning...")

        for porta in portas:
            t = threading.Thread(target=self.scan_porta, args=(host, int(porta)))
            t.start()

    def scan_porta(self, host, porta):
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(1)
        resultado = sock.connect_ex((host, porta))
        if resultado == 0:
            self.label_resultado.setText(f"Porta {porta} aberta")

app = QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_())

Versão Avançada com Suporte TCP/UDP

Esta versão inclui suporte para ambos os protocolos:

import socket
import threading
from PyQt5 import QtWidgets

class Portscan(QtWidgets.QWidget):
    def __init__(self):
        super().__init__()
        self.init_ui()

    def init_ui(self):
        self.setWindowTitle('Port Scanner Avançado')
        self.setGeometry(100, 100, 400, 300)
        
        # Elementos da interface
        self.host_input = QtWidgets.QLineEdit(self)
        self.start_port_input = QtWidgets.QLineEdit(self)
        self.end_port_input = QtWidgets.QLineEdit(self)
        self.results_list = QtWidgets.QListWidget(self)
        
        # Botões
        self.tcp_scan_button = QtWidgets.QPushButton('Scan TCP', self)
        self.tcp_scan_button.clicked.connect(self.scan_tcp_ports)
        
        self.udp_scan_button = QtWidgets.QPushButton('Scan UDP', self)
        self.udp_scan_button.clicked.connect(self.scan_udp_ports)
        
        # Layout
        layout = QtWidgets.QVBoxLayout()
        layout.addWidget(QtWidgets.QLabel('Host:'))
        layout.addWidget(self.host_input)
        layout.addWidget(QtWidgets.QLabel('Porta Inicial:'))
        layout.addWidget(self.start_port_input)
        layout.addWidget(QtWidgets.QLabel('Porta Final:'))
        layout.addWidget(self.end_port_input)
        
        button_layout = QtWidgets.QHBoxLayout()
        button_layout.addWidget(self.tcp_scan_button)
        button_layout.addWidget(self.udp_scan_button)
        
        layout.addLayout(button_layout)
        layout.addWidget(QtWidgets.QLabel('Resultados:'))
        layout.addWidget(self.results_list)
        
        self.setLayout(layout)

    def scan_tcp_ports(self):
        self.scan_ports('TCP')

    def scan_udp_ports(self):
        self.scan_ports('UDP')

    def scan_ports(self, protocol):
        host = self.host_input.text()
        start_port = int(self.start_port_input.text())
        end_port = int(self.end_port_input.text())
        
        self.results_list.clear()
        
        for port in range(start_port, end_port + 1):
            t = threading.Thread(target=self.scan_port, args=(host, port, protocol))
            t.start()

    def scan_port(self, host, port, protocol):
        try:
            if protocol == 'TCP':
                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                    s.settimeout(0.5)
                    if s.connect_ex((host, port)) == 0:
                        self.results_list.addItem(f'Porta {port} aberta (TCP)')
            else:
                with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
                    s.settimeout(0.5)
                    s.sendto(b'', (host, port))
                    if s.recvfrom(1024):
                        self.results_list.addItem(f'Porta {port} aberta (UDP)')
        except:
            pass

app = QtWidgets.QApplication([])
portscan = Portscan()
portscan.show()
app.exec_()

Versão com ListBox e Design Aprimorado

Para uma experiência mais profissional:

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QLabel, QGridLayout, 
                            QWidget, QGroupBox, QListWidget, QLineEdit, 
                            QVBoxLayout, QHBoxLayout, QPushButton)
from PyQt5.QtGui import QFont
import socket
import threading

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Port Scanner Profissional")
        self.setGeometry(100, 100, 600, 400)
        
        # Configuração da interface
        self.create_input_group()
        self.create_results_group()
        
        # Layout principal
        main_widget = QWidget()
        main_layout = QVBoxLayout()
        main_layout.addWidget(self.input_groupbox)
        main_layout.addWidget(self.results_groupbox)
        main_widget.setLayout(main_layout)
        
        self.setCentralWidget(main_widget)
    
    def create_input_group(self):
        self.input_groupbox = QGroupBox("Configurações do Scan")
        layout = QGridLayout()
        
        self.ip_edit = QLineEdit()
        self.ip_edit.setPlaceholderText("Ex: 192.168.1.1")
        
        self.start_port_edit = QLineEdit()
        self.start_port_edit.setPlaceholderText("Porta inicial")
        
        self.end_port_edit = QLineEdit()
        self.end_port_edit.setPlaceholderText("Porta final")
        
        scan_button = QPushButton("Iniciar Scan")
        scan_button.clicked.connect(self.start_scan)
        
        layout.addWidget(QLabel("Endereço IP:"), 0, 0)
        layout.addWidget(self.ip_edit, 0, 1)
        layout.addWidget(QLabel("Porta Inicial:"), 1, 0)
        layout.addWidget(self.start_port_edit, 1, 1)
        layout.addWidget(QLabel("Porta Final:"), 2, 0)
        layout.addWidget(self.end_port_edit, 2, 1)
        layout.addWidget(scan_button, 3, 0, 1, 2)
        
        self.input_groupbox.setLayout(layout)
    
    def create_results_group(self):
        self.results_groupbox = QGroupBox("Resultados")
        layout = QVBoxLayout()
        
        self.results_list = QListWidget()
        layout.addWidget(self.results_list)
        
        self.results_groupbox.setLayout(layout)
    
    def start_scan(self):
        host = self.ip_edit.text()
        start_port = int(self.start_port_edit.text())
        end_port = int(self.end_port_edit.text())
        
        self.results_list.clear()
        
        for port in range(start_port, end_port + 1):
            t = threading.Thread(target=self.check_port, args=(host, port))
            t.start()
    
    def check_port(self, host, port):
        try:
            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                s.settimeout(1)
                if s.connect_ex((host, port)) == 0:
                    self.results_list.addItem(f"Porta {port} - aberta")
                else:
                    self.results_list.addItem(f"Porta {port} - fechada")
        except Exception as e:
            self.results_list.addItem(f"Erro na porta {port}: {str(e)}")

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())

Considerações de Segurança

Ao usar um port scanner, lembre-se:

• Nunca escane redes sem permissão explícita
• O uso indevido pode violar leis de privacidade
• Configure tempos de timeout adequados para não sobrecarregar sistemas

Para mais informações sobre sockets em Python, consulte a documentação oficial.

Pre-requisitos e Materiais

Antes de executar qualsiasi passo tecnico, valide o ambiente: versao, dependencias e credenciais. Pular essa checagem causa retrabalho porque erros simples sao interpretados como falhas do procedimento.

Separe um diretorio de teste de outro de producao para comparar comportamento sem risco.

Validacao Pos-execucao

Depois de executar o passo original, registre saidas, arquivos alterados e endpoints respondidos. Esses dados viram referencia rapida na repeticao.

Nao avance enquanto o passo atual nao puder ser explicado em tres linhas.

Troubleshooting Rapido

Se um comando falhar, registre exatamente a mensagem e o passo anterior. Muitos erros tecnicos so parecem novos porque o contexto original nao foi registrado.

Reverta alteracoes antes de repetir; sequencia sem volta aumenta o custo do erro.

Fontes e Referencias

• Conteudo original
• Buscar no @CanalQb
• IAPP Global Privacy Directory

Nota Tecnica: Este post e estritamente informativo. Teste em ambiente controlado antes de repetir procedimentos.

Perguntas Frequentes

O que e Como Criar um Port Scanner em Python com Interface Gráfica PyQt?

Como Criar um Port Scanner em Python com Interface Gráfica PyQt traz contexto que deve ser validado no site oficial. Este modernizado preserva o backup do @CanalQb para reduzir perda de informacao.

Ainda e valido usar Como Criar um Port Scanner em Python com Interface Gráfica PyQt em 2026?

O conteudo original e a base, mas regras e endpoints podem mudar. Verifique fontes atuais antes de executar.

Como aumentar resultado no Como Criar um Port Scanner em Python com Interface Gráfica PyQt?

Consistencia supera spam. Aplique o passo original e confirme atualizacoes oficiais antes de escalar acoes.

Onde estao as fontes oficiais de Como Criar um Port Scanner em Python com Interface Gráfica PyQt?

Use os dominios registrados neste post e priorize documentacao oficial, changelog ou comunicados.

Como Criar um Port Scanner em Python com Interface Gráfica PyQt exige conhecimento previo?

Se parecer denso, comece por pre-requisitos e use o backup como apoio. Mantenha passos curtos e verificaveis.

Revisado em 2026-07-11

Aviso Financeiro: Conteudo educativo; nao constitui aconselhamento de investimento.

Gostou do conteudo? Inscreva-se no @CanalQb no YouTube e ative o sininho.

Feito com Master Rules Claude v8.6 - @CanalQb

Guia Resumido

Resumo operacional: mantenha o foco no metodo, registre resultados e confirme fontes antes de escalar passos tecnicos.

Segunda Verificacao

A segunda passada reduz erros de primeira execucao. Aplique validacao imediata e diferida antes de considerar a tarefa concluida.

Terceira Verificacao

A terceira leitura separa procedimento que funciona de procedimento que parece funcionar. Ajuste pequenos pontos antes de avancar.

Revisao Final

A revisao final cruza acao planejada com acao executada. Sempre que possivel, compare metrica atual com metrica anterior.

Observacoes Complementares

Guardando referencias de consulta, voce reduz tempo gasto com buscas repetidas e ganha clareza para priorizar.

Pontos de Atencao

Atencao pequena evita retrabalho grande. Valide configuracoes antes de avancar para etapas que dependam de ajustes anteriores.

Verificacoes Praticas Recomendadas

Tutoriais tecnicos evoluem rapido: comandos, repositorios e pacotes podem mudar entre versoes. Antes de repetir, confirme versao do sistema, caminhos e permissoes.

Ao longo de entregas do @CanalQb, essa checagem reduz retrabalho e evita que erros simples parecam falha do script.

• Consulte a documentacao da versao instalada.
• Teste ajustes sensiveis em ambiente separado primeiro.
• Registre logs e saidas para repeticao segura.

Pre-requisitos e Materiais

Antes de executar qualsiasi passo tecnico, valide o ambiente: versao, dependencias e credenciais. Pular essa checagem causa retrabalho porque erros simples sao interpretados como falhas do procedimento.

Separe um diretorio de teste de outro de producao para comparar comportamento sem risco.

Validacao Pos-execucao

Depois de executar o passo original, registre saidas, arquivos alterados e endpoints respondidos. Esses dados viram referencia rapida na repeticao.

Nao avance enquanto o passo atual nao puder ser explicado em tres linhas.

Troubleshooting Rapido

Se um comando falhar, registre exatamente a mensagem e o passo anterior. Muitos erros tecnicos so parecem novos porque o contexto original nao foi registrado.

Reverta alteracoes antes de repetir; sequencia sem volta aumenta o custo do erro.

Checklist de Execucao Segura

• Confirme o objetivo principal antes de repetir o roteiro.
• Valide o passo original com uma execucao de baixo risco.
• Registre resultado, tempo gasto e desvios encontrados.
• Se algo travar, reduza escopo ao trecho suspeito antes de refazer tudo.
• Compare saidas esperadas com saidas reais antes de seguir.

Erros Comuns e Como Evita-los

Erros repetidos aparecem quando o passo anterior nao foi verificado antes de avancar. Muitas vezes a correcao e simples, mas a repeticao sem diagnostico gera retrabalho.

Ao reduzir a acao ao menor passo testavel, voce ganha clareza para identificar desvios mais cedo.

Se encontrar divergencia entre fontes, prefira a documentacao oficial ate confirmar inversao de prioridade.

Documentacao e Continuidade

Registre mudancas data, causa e correcao aplicada. Esse habito reduz erros e acelera revisoes futuras.

Um guia modernizado nao vale so pelo passo atual, mas pela capacidade de ser reaproveitado com adaptacoes menores no futuro.