பைத்தான் சைபர் செக்யூரிட்டி: நெறிமுறை ஹேக்கர்களுக்கான ஊடுருவல் சோதனை கருவிகள்

இன்றைய டிஜிட்டல் உலகில், சைபர் செக்யூரிட்டி மிக முக்கியமானது. நிறுவனங்கள் தொழில்நுட்பத்தை அதிகளவில் நம்பியிருப்பதால், திறமையான சைபர் செக்யூரிட்டி நிபுணர்களின் தேவை முன்னெப்போதையும் விட அதிகமாக உள்ளது. ஊடுருவல் சோதனை, நெறிமுறை ஹேக்கிங் என்றும் அழைக்கப்படுகிறது, இது தீங்கிழைக்கும் நபர்கள் சுரண்டுவதற்கு முன்பு பாதிப்புகளைக் கண்டறிந்து தணிப்பதில் முக்கிய பங்கு வகிக்கிறது. பைத்தான், அதன் பல்துறை மற்றும் விரிவான லைப்ரரிகளுடன், உலகெங்கிலும் உள்ள ஊடுருவல் சோதனையாளர்களுக்கு விருப்பமான மொழியாக மாறியுள்ளது. இந்த விரிவான வழிகாட்டி அத்தியாவசிய பைத்தான் ஊடுருவல் சோதனை கருவிகள், நெறிமுறை ஹேக்கிங் கோட்பாடுகள் மற்றும் உங்கள் சைபர் செக்யூரிட்டி திறன்களை எவ்வாறு மேம்படுத்துவது என்பதை ஆராய்கிறது.

ஊடுருவல் சோதனை என்றால் என்ன?

ஊடுருவல் சோதனை என்பது ஒரு கணினி அமைப்பு, நெட்வொர்க் அல்லது வலை பயன்பாட்டிற்கு எதிராக பாதுகாப்பு பாதிப்புகளைக் கண்டறிய செய்யப்படும் ஒரு உருவகப்படுத்தப்பட்ட சைபர் தாக்குதல் ஆகும். நெறிமுறை ஹேக்கர்கள், ஊடுருவல் சோதனையாளர்கள் என்றும் அழைக்கப்படுகிறார்கள், தீங்கிழைக்கும் ஹேக்கர்கள் பயன்படுத்தும் அதே நுட்பங்களைப் பயன்படுத்துகிறார்கள், ஆனால் நிறுவனத்தின் அனுமதியுடன் மற்றும் பாதுகாப்பை மேம்படுத்தும் நோக்கத்துடன். இந்த செயல்முறை பொதுவாக உள்ளடக்கியது:

• திட்டமிடல் மற்றும் உளவு பார்த்தல்: சோதனையின் நோக்கம் மற்றும் குறிக்கோள்களை வரையறுத்தல், இலக்கு அமைப்பு பற்றிய தகவல்களைச் சேகரித்தல் மற்றும் சாத்தியமான பாதிப்புகளைக் கண்டறிதல்.
• ஸ்கேனிங்: இலக்கு அமைப்பில் இயங்கும் திறந்த போர்ட்கள், சேவைகள் மற்றும் இயக்க முறைமைகளைக் கண்டறிய கருவிகளைப் பயன்படுத்துதல்.
• அணுகலைப் பெறுதல்: கணினிக்கு அணுகலைப் பெற அடையாளம் காணப்பட்ட பாதிப்புகளை சுரண்டுதல்.
• அணுகலைப் பராமரித்தல்: தகவல்களைச் சேகரிக்க அல்லது கணினியை மேலும் சமரசம் செய்ய போதுமான நேரம் கணினிக்கான அணுகலைப் பராமரித்தல்.
• பகுப்பாய்வு: கண்டுபிடிப்புகளை பகுப்பாய்வு செய்தல், பாதிப்புகளை ஆவணப்படுத்துதல் மற்றும் சரிசெய்வதற்கான பரிந்துரைகளை வழங்குதல்.

ஊடுருவல் சோதனைக்கு பைத்தான் ஏன்?

ஊடுருவல் சோதனைக்கு பைத்தான் பல நன்மைகளை வழங்குகிறது:

• பயன்படுத்த எளிதானது: பைத்தானின் எளிய மற்றும் படிக்கக்கூடிய தொடரியல், வரையறுக்கப்பட்ட நிரலாக்க அனுபவம் உள்ளவர்களுக்கும் கூட கற்றுக்கொள்வதையும் பயன்படுத்துவதையும் எளிதாக்குகிறது.
• விரிவான லைப்ரரிகள்: பைத்தான் சைபர் செக்யூரிட்டி பணிகளுக்காக பிரத்யேகமாக வடிவமைக்கப்பட்ட லைப்ரரிகள் மற்றும் மாட்யூல்களின் வளமான சூழலைக் கொண்டுள்ளது.
• குறுக்கு-தளம் இணக்கத்தன்மை: விண்டோஸ், மேக்ஓஎஸ் மற்றும் லினக்ஸ் உள்ளிட்ட பல்வேறு இயக்க முறைமைகளில் பைத்தான் தடையின்றி இயங்குகிறது.
• விரைவான மேம்பாடு: பைத்தானின் டைனமிக் டைப்பிங் மற்றும் இன்டர்ப்ரெட் செய்யப்பட்ட தன்மை, தனிப்பயன் கருவிகளின் விரைவான முன்மாதிரி மற்றும் மேம்பாட்டிற்கு அனுமதிக்கிறது.
• சமூக ஆதரவு: ஒரு பெரிய மற்றும் சுறுசுறுப்பான சமூகம் பைத்தான் டெவலப்பர்களுக்கு ஏராளமான ஆதாரங்கள், ஆவணங்கள் மற்றும் ஆதரவை வழங்குகிறது.

அத்தியாவசிய பைத்தான் ஊடுருவல் சோதனை கருவிகள்

ஊடுருவல் சோதனைக்கு மிகவும் பரவலாகப் பயன்படுத்தப்படும் சில பைத்தான் லைப்ரரிகள் மற்றும் கருவிகளின் விரிவான பார்வை இங்கே:

1. Nmap (நெட்வொர்க் மேப்பர்)

விளக்கம்: Nmap ஒரு சக்திவாய்ந்த நெட்வொர்க் ஸ்கேனிங் மற்றும் போர்ட் கணக்கெடுப்பு கருவியாகும். இது கண்டிப்பாக ஒரு பைத்தான் லைப்ரரி இல்லை என்றாலும், இது ஒரு பைத்தான் API (python-nmap) கொண்டுள்ளது, இது உங்கள் பைத்தான் ஸ்கிரிப்ட்களில் Nmap செயல்பாட்டை ஒருங்கிணைக்க உங்களை அனுமதிக்கிறது. பாக்கெட்டுகளை அனுப்பி பதில்களை பகுப்பாய்வு செய்வதன் மூலம் கணினி நெட்வொர்க்கில் ஹோஸ்ட்கள் மற்றும் சேவைகளைக் கண்டறிய Nmap பயன்படுத்தப்படுகிறது.

பயன்பாட்டு வழக்குகள்:

• ஹோஸ்ட் கண்டுபிடிப்பு: ஒரு நெட்வொர்க்கில் நேரடி ஹோஸ்ட்களை அடையாளம் காணுதல்.
• போர்ட் ஸ்கேனிங்: ஒரு ஹோஸ்டில் இயங்கும் திறந்த போர்ட்கள் மற்றும் சேவைகளை தீர்மானித்தல்.
• இயக்க முறைமை கண்டறிதல்: ஒரு ஹோஸ்டில் இயங்கும் இயக்க முறைமை மற்றும் பதிப்பை அடையாளம் காணுதல்.
• பதிப்பு கண்டறிதல்: ஒரு சேவையில் இயங்கும் மென்பொருளின் பதிப்பை அடையாளம் காணுதல்.
• பாதிப்பு ஸ்கேனிங்: சேவை மற்றும் பதிப்பு தகவலின் அடிப்படையில் அறியப்பட்ட பாதிப்புகளை அடையாளம் காணுதல்.

உதாரணம்:

            import nmap

scanner = nmap.PortScanner()

scanner.scan(hosts='192.168.1.0/24', arguments='-T4 -F')

for host in scanner.all_hosts():
    print('Host : %s (%s)' % (host, scanner[host].hostname()))
    print('State : %s' % scanner[host].state())
    for proto in scanner[host].all_protocols():
        print('----------')
        print('Protocol : %s' % proto)
        lport = scanner[host][proto].keys()
        for port in lport:
            print('port : %s\tstate : %s' % (port, scanner[host][proto][port]['state']))

            

              
                Copy
              
            
          

2. ஸ்கேப்பி

விளக்கம்: ஸ்கேப்பி ஒரு சக்திவாய்ந்த ஊடாடும் பாக்கெட் கையாளுதல் நிரலாகும். இது நெட்வொர்க் பாக்கெட்டுகளை உருவாக்க, டிகோட் செய்ய, கைப்பற்ற மற்றும் செலுத்த உங்களை அனுமதிக்கிறது. ஸ்கேப்பி மிகவும் நெகிழ்வானது மற்றும் நெட்வொர்க் கண்டுபிடிப்பு, ஸ்னிஃபிங், பாக்கெட் உருவாக்கம் மற்றும் நெறிமுறை சோதனை உள்ளிட்ட பரந்த அளவிலான பணிகளுக்குப் பயன்படுத்தப்படலாம்.

பயன்பாட்டு வழக்குகள்:

• பாக்கெட் ஸ்னிஃபிங்: நெட்வொர்க் போக்குவரத்தை கைப்பற்றி தனிப்பட்ட பாக்கெட்டுகளை பகுப்பாய்வு செய்தல்.
• பாக்கெட் உருவாக்கம்: சோதனை மற்றும் சுரண்டலுக்காக தனிப்பயன் நெட்வொர்க் பாக்கெட்டுகளை உருவாக்குதல்.
• நெட்வொர்க் கண்டுபிடிப்பு: ஒரு நெட்வொர்க்கில் ஹோஸ்ட்கள் மற்றும் சேவைகளை அடையாளம் காணுதல்.
• நெறிமுறை சோதனை: நெட்வொர்க் நெறிமுறைகளின் செயலாக்கத்தை சோதித்தல்.
• சேவை மறுப்பு (DoS) தாக்குதல்கள்: சோதனை நோக்கங்களுக்காக DoS தாக்குதல்களை உருவகப்படுத்துதல்.

உதாரணம்:

            from scapy.all import *

packet = IP(dst='192.168.1.1')/TCP(dport=80, flags='S')

response = sr1(packet, timeout=2, verbose=0)

if response and response.haslayer(TCP):
    if response.getlayer(TCP).flags == 0x12:
        print('Port 80 is open')
    else:
        print('Port 80 is closed')
else:
    print('Port 80 is filtered or host is down')

            

              
                Copy
              
            
          

3. மெட்டாஸ்ப்ளாயிட்

விளக்கம்: மெட்டாஸ்ப்ளாயிட் என்பது பரவலாகப் பயன்படுத்தப்படும் ஒரு ஊடுருவல் சோதனை கட்டமைப்பாகும், இது பாதிப்பு மதிப்பீடு, சுரண்டல் மற்றும் சுரண்டலுக்குப் பிந்தைய நடவடிக்கைகளுக்கான விரிவான கருவிகளை வழங்குகிறது. இது பல்வேறு இயக்க முறைமைகள், பயன்பாடுகள் மற்றும் சேவைகளுக்கான சுரண்டல்களின் ஒரு பெரிய தரவுத்தளத்தைக் கொண்டுள்ளது. மெட்டாஸ்ப்ளாயிட்டின் முக்கிய பகுதி ரூபியில் எழுதப்பட்டிருந்தாலும், இது ஒரு பைத்தான் API ஐக் கொண்டுள்ளது, இது உங்கள் பைத்தான் ஸ்கிரிப்ட்களிலிருந்து மெட்டாஸ்ப்ளாயிட் மாட்யூல்களுடன் தொடர்பு கொள்ள உங்களை அனுமதிக்கிறது.

பயன்பாட்டு வழக்குகள்:

• பாதிப்பு சுரண்டல்: கணினிகளுக்கு அணுகலைப் பெற அறியப்பட்ட பாதிப்புகளைச் சுரண்டுதல்.
• சுரண்டலுக்குப் பிந்தைய நடவடிக்கைகள்: தகவல்களைச் சேகரித்தல், சலுகைகளை உயர்த்துதல் மற்றும் பின்கதவுகளை நிறுவுதல் போன்ற சமரசம் செய்யப்பட்ட கணினியில் செயல்களைச் செய்தல்.
• பேலோடு உருவாக்கம்: சுரண்டலுக்காக தனிப்பயன் பேலோடுகளை உருவாக்குதல்.
• துணை மாட்யூல்கள்: ஸ்கேனிங், ஃபஸ்ஸிங் மற்றும் கடவுச்சொல் கிராக்கிங் போன்ற பணிகளுக்கு துணை மாட்யூல்களைப் பயன்படுத்துதல்.

உதாரணம்: (இந்த உதாரணத்திற்கு ஒரு இயங்கும் மெட்டாஸ்ப்ளாயிட் நிகழ்வு மற்றும் பொருத்தமான அமைப்பு தேவை)

            # This is a simplified example and requires proper setup
# to interact with a Metasploit instance.

import msfrpc

client = msfrpc.MsfRpcClient('password', port=55552)

# Execute a module (example: auxiliary/scanner/portscan/tcp)
module = client.modules.auxiliary.scanner_portscan_tcp
module.options['RHOSTS'] = '192.168.1.100'
module.options['THREADS'] = 10
result = module.execute(wait=True)

print(result)

            

              
                Copy
              
            
          

4. பர்ப் சூட் (ஜைத்தான் வழியாக)

விளக்கம்: பர்ப் சூட் என்பது ஒரு பிரபலமான வலை பயன்பாட்டு பாதுகாப்பு சோதனை கருவியாகும். இது உங்கள் உலாவிக்கும் வலை சேவையகத்திற்கும் இடையில் ஒரு ப்ராக்ஸியாக செயல்படுகிறது, இது HTTP போக்குவரத்தை இடைமறிக்க, ஆய்வு செய்ய மற்றும் மாற்றியமைக்க உங்களை அனுமதிக்கிறது. பர்ப் சூட் முதன்மையாக ஒரு GUI-அடிப்படையிலான கருவியாக இருந்தாலும், பணிகளை தானியக்கமாக்குவதற்கும் அதன் செயல்பாட்டைத் தனிப்பயனாக்குவதற்கும் ஜைத்தானில் (ஜாவா மெய்நிகர் இயந்திரத்தில் இயங்கும் பைத்தான்) எழுதப்பட்ட நீட்டிப்புகளை இது ஆதரிக்கிறது.

பயன்பாட்டு வழக்குகள்:

• வலை பயன்பாட்டு ஸ்கேனிங்: SQL ஊசி, குறுக்கு-தள ஸ்கிரிப்டிங் (XSS) மற்றும் கட்டளை ஊசி போன்ற வலை பயன்பாடுகளில் உள்ள பாதிப்புகளை அடையாளம் காணுதல்.
• ப்ராக்ஸி இடைமறிப்பு: HTTP போக்குவரத்தை இடைமறித்தல் மற்றும் மாற்றியமைத்தல்.
• ஊடுருவல் தாக்குதல்கள்: வலை பயன்பாடுகளில் முரட்டுத்தனமான மற்றும் ஃபஸ்ஸிங் தாக்குதல்களைச் செய்தல்.
• ரிப்பீட்டர்: HTTP கோரிக்கைகளை கைமுறையாக உருவாக்குதல் மற்றும் அனுப்புதல்.
• செயல்பாட்டை நீட்டித்தல்: பணிகளை தானியக்கமாக்குதல் மற்றும் ஜைத்தான் நீட்டிப்புகளைப் பயன்படுத்தி தனிப்பயன் அம்சங்களைச் சேர்த்தல்.

உதாரணம் (ஜைத்தானில் பர்ப் சூட் நீட்டிப்பு):

            # Jython code for Burp Suite extension
from burp import IBurpExtender
from burp import IHttpListener

class BurpExtender(IBurpExtender, IHttpListener):
    
    def registerExtenderCallbacks(self, callbacks):
        # Obtain an extension helpers object
        self._helpers = callbacks.getHelpers()
        
        # Set our extension name
        callbacks.setExtensionName("Example HTTP Listener")
        
        # Register ourselves as an HTTP listener
        callbacks.registerHttpListener(self)
        
        return
    
    def processHttpMessage(self, toolFlag, messageIsRequest, messageInfo):
        # Only process requests
        if messageIsRequest:
            # Get the HTTP request
            request = messageInfo.getRequest()
            
            # Convert the request to a string
            request_string = self._helpers.bytesToString(request)
            
            # Print the request to the Extensions output tab
            print "New HTTP request:\n" + request_string
        
        return

            

              
                Copy
              
            
          

5. OWASP ZAP (செட் அட்டாக் ப்ராக்ஸி)

விளக்கம்: OWASP ZAP என்பது ஒரு இலவச மற்றும் திறந்த மூல வலை பயன்பாட்டு பாதுகாப்பு ஸ்கேனர் ஆகும். பர்ப் சூட்டைப் போலவே, இது ஒரு ப்ராக்ஸியாக செயல்படுகிறது மற்றும் HTTP போக்குவரத்தை இடைமறிக்க, ஆய்வு செய்ய மற்றும் மாற்றியமைக்க உங்களை அனுமதிக்கிறது. OWASP ZAP ஒரு பயனர் நட்பு இடைமுகம் மற்றும் தானியங்கு ஸ்கேனிங், கைமுறை ஆய்வு மற்றும் அறிக்கையிடல் உள்ளிட்ட பரந்த அளவிலான அம்சங்களை வழங்குகிறது.

பயன்பாட்டு வழக்குகள்:

• தானியங்கு ஸ்கேனிங்: வலை பயன்பாடுகளில் உள்ள பாதிப்புகளை தானாகவே அடையாளம் காணுதல்.
• கைமுறை ஆய்வு: வலை பயன்பாடுகளை கைமுறையாக ஆராய்ந்து பாதிப்புகளை அடையாளம் காணுதல்.
• AJAX ஸ்பைடர்: AJAX-அடிப்படையிலான வலை பயன்பாடுகளை கிரால் செய்தல் மற்றும் ஸ்கேன் செய்தல்.
• கட்டாய உலாவல்: ஒரு வலை சேவையகத்தில் மறைக்கப்பட்ட கோப்புகள் மற்றும் கோப்பகங்களைக் கண்டறிதல்.
• அறிக்கையிடல்: அடையாளம் காணப்பட்ட பாதிப்புகள் குறித்த அறிக்கைகளை உருவாக்குதல்.

உதாரணம் (பைத்தானுடன் ZAP API ஐப் பயன்படுத்துதல்):

            from zapv2 import ZAPv2

# Configure ZAP proxy
ZAP_PROXY_ADDRESS = '127.0.0.1'
ZAP_PROXY_PORT = 8080

# Target URL
target_url = 'http://example.com'

# Initialize ZAP API
zap = ZAPv2(proxies={'http': f'http://{ZAP_PROXY_ADDRESS}:{ZAP_PROXY_PORT}', 'https': f'http://{ZAP_PROXY_ADDRESS}:{ZAP_PROXY_PORT}'})

# Spider the target
print(f'Spidering target {target_url}')
zap.spider.scan(target_url)

# Give the Spider a chance to start
import time
time.sleep(2)

# Poll the status until it is finished
while int(zap.spider.status) < 100:
    print(f'Spider progress {zap.spider.status}%')
    time.sleep(5)

print(f'Spider completed')

# Active scan the target
print(f'Active Scanning target {target_url}')
zap.ascan.scan(target_url)

# Give the scanner a chance to start
time.sleep(2)

# Poll the status until it is finished
while int(zap.ascan.status) < 100:
    print(f'Scan progress {zap.ascan.status}%')
    time.sleep(5)

print(f'Active Scan completed')

# Generate an HTML report
print(f'Generating HTML report')
report = zap.core.htmlreport
with open('zap_report.html', 'w') as f:
    f.write(report)

print(f'Report generated: zap_report.html')

            

              
                Copy
              
            
          

6. ரிக்வெஸ்ட்ஸ் (Requests)

விளக்கம்: ரிக்வெஸ்ட்ஸ் என்பது பைத்தானுக்கான ஒரு எளிய மற்றும் நேர்த்தியான HTTP லைப்ரரி ஆகும். இது HTTP கோரிக்கைகளை எளிதாக அனுப்பவும், பதில்களை திறம்பட கையாளவும் உங்களை அனுமதிக்கிறது. ஊடுருவல் சோதனையில் வலை சேவைகள் மற்றும் APIகளுடன் தொடர்புகொள்வதற்கான ஒரு அடிப்படை லைப்ரரி ரிக்வெஸ்ட்ஸ் ஆகும்.

பயன்பாட்டு வழக்குகள்:

• வலை பயன்பாட்டு சோதனை: வலை பயன்பாடுகளுக்கு HTTP கோரிக்கைகளை அனுப்பி பதில்களை பகுப்பாய்வு செய்தல்.
• API சோதனை: APIகளுடன் தொடர்புகொண்டு அவற்றின் செயல்பாட்டை சோதித்தல்.
• ஃபஸ்ஸிங்: பாதிப்புகளை அடையாளம் காண மாறுபட்ட அளவுருக்களுடன் அதிக எண்ணிக்கையிலான கோரிக்கைகளை அனுப்புதல்.
• வலை ஸ்கிராப்பிங்: வலைப்பக்கங்களிலிருந்து தரவைப் பிரித்தெடுத்தல்.

உதாரணம்:

            import requests

url = 'http://example.com'

try:
    response = requests.get(url, timeout=5)
    response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
    print(f'Status code: {response.status_code}')
    print(f'Content: {response.content[:200]}...')  # Print first 200 characters
except requests.exceptions.RequestException as e:
    print(f'An error occurred: {e}')

            

              
                Copy
              
            
          

7. பியூட்டிஃபுல் சூப் (BeautifulSoup)

விளக்கம்: பியூட்டிஃபுல் சூப் என்பது HTML மற்றும் XML ஆவணங்களைப் பாகுபடுத்துவதற்கான ஒரு பைத்தான் லைப்ரரி ஆகும். இது ஆவண மரத்தில் செல்லவும், குறிப்பிட்ட கூறுகளைத் தேடவும், தரவைப் பிரித்தெடுக்கவும் உங்களை அனுமதிக்கிறது. பியூட்டிஃபுல் சூப் பெரும்பாலும் வலை ஸ்கிராப்பிங் மற்றும் பாதிப்பு பகுப்பாய்விற்காக ரிக்வெஸ்ட்ஸ் உடன் இணைந்து பயன்படுத்தப்படுகிறது.

பயன்பாட்டு வழக்குகள்:

• வலை ஸ்கிராப்பிங்: வலைப்பக்கங்களிலிருந்து தரவைப் பிரித்தெடுத்தல்.
• பாதிப்பு பகுப்பாய்வு: HTML குறியீட்டில் உள்ள பாதிப்புகளை அடையாளம் காணுதல்.
• தரவு பிரித்தெடுத்தல்: HTML மற்றும் XML ஆவணங்களிலிருந்து குறிப்பிட்ட தரவைப் பிரித்தெடுத்தல்.

உதாரணம்:

            import requests
from bs4 import BeautifulSoup

url = 'http://example.com'

response = requests.get(url)

soup = BeautifulSoup(response.content, 'html.parser')

# Find all links on the page
links = soup.find_all('a')

for link in links:
    print(link.get('href'))

            

              
                Copy
              
            
          

8. பான்டூல்ஸ் (Pwntools)

விளக்கம்: பான்டூல்ஸ் என்பது ஒரு CTF (கேப்சர் தி பிளாக்) கட்டமைப்பு மற்றும் பைத்தானில் எழுதப்பட்ட சுரண்டல் மேம்பாட்டு லைப்ரரி ஆகும். இது செயல்முறைகள், நெட்வொர்க்குகள் மற்றும் கோப்புகளுடன் தொடர்புகொள்வதற்கான பரந்த அளவிலான கருவிகள் மற்றும் செயல்பாடுகளை வழங்குகிறது, இது பைனரி சுரண்டல் மற்றும் தலைகீழ் பொறியியலுக்கு பயனுள்ளதாக அமைகிறது.

பயன்பாட்டு வழக்குகள்:

            from pwn import *

# Connect to a remote process
conn = remote('example.com', 1337)

# Send some data
conn.sendline('hello')

# Receive some data
response = conn.recvline()

print(response)

# Close the connection
conn.close()

            

              
                Copy
              
            
          

            # Example: Simple SMB connection (requires proper setup and credentials)
from impacket import smb
from impacket.smbconnection import SMBConnection

target_ip = '192.168.1.10'
target_name = 'TARGET_SERVER'
username = 'username'
password = 'password'

try:
    smb_connection = SMBConnection(target_name, target_ip, sess_port=445)
    smb_connection.login(username, password)
    print(f'Successfully connected to {target_ip}')
    smb_connection.close()

except Exception as e:
    print(f'Error connecting to SMB: {e}')

            

              
                Copy