Python yordamida HTTP so'rovlarini skanerlash

Python yordamida HTTP so'rovlarini skanerlash — bu veb-saytlar va veb-ilovalarning ishlashini va ularning zaifliklarini aniqlash uchun amalga oshiriladigan jarayon. Ushbu jarayonda turli xil HTTP metodlaridan foydalangan holda veb-serverlarga so‘rovlar yuboriladi, javoblar tahlil qilinadi va potentsial zaifliklar aniqlanadi. Linux operatsion tizimi uchun Python yordamida HTTP so'rovlarini skanerlashni chuqurroq tushuntirib o'taman.

Asosiy tushunchalar:

HTTP metodlari: Asosiy HTTP metodlariga quyidagilar kiradi:

• GET: Ma'lumot olish uchun ishlatiladi.

• POST: Ma'lumot jo'natish uchun ishlatiladi.

• PUT: Resursni yaratish yoki yangilash uchun ishlatiladi.

• DELETE: Resursni o'chirish uchun ishlatiladi.

• HEAD: GET so'roviga o'xshash, lekin faqatgina javobning header qismini qaytaradi.

• OPTIONS: Server tomonidan qo'llab-quvvatlanadigan metodlar haqida ma'lumot beradi.

1. HTTP status kodlari: Javobdan kelgan status kodlar sayt yoki API-ning ishlashini tahlil qilishda muhim rol o'ynaydi:

   • 2xx: Muvaffaqiyatli so'rovlar (200 – OK, 201 – Created).

   • 3xx: Yuborilgan so'rovlar qayta yo'naltirilgan (301 – Moved Permanently, 302 – Found).

   • 4xx: Klient xatolari (404 – Not Found, 403 – Forbidden).

   • 5xx: Server xatolari (500 – Internal Server Error, 502 – Bad Gateway).

   

   

   Bu rasm HTTP/2 protokolidagi ma'lumot siqish va optimizatsiyani tasvirlaydi. Yana aniqroq qilib aytadigan bo'lsak, rasm HTTP/2 protokolidagi header siqish va qayta ishlatish (header compression va reuse) texnologiyasini ko'rsatadi. Bu protokol ma'lumotlarni qayta-qayta yuborish o'rniga, avval yuborilgan ma'lumotlarni saqlab qolib, faqat o'zgargan qismlarini yuboradi.

   Asosiy Tushuncha:

   HTTP/2 protokolida, birinchi so'rovda yuborilgan header'lar keyingi so'rovlar uchun eslab qolinadi. Agar keyingi so'rovda header ma'lumotlari deyarli bir xil bo'lsa, protokol faqat o'zgargan qismini yuboradi, qolganlari esa avtomatik ravishda birinchi so'rovga asoslanib tushuniladi.

Qadam-baqadam tushuntirish:

Request #1 (Birinchi so'rov): To'liq ma'lumot yuboriladi

1. Birinchi so'rov bu yerda to'liq ma'lumotlarni o'z ichiga oladi.

   • : GET (bu GET so'rovi, ya'ni serverdan ma'lumot so'rash).

   • : https (so'rov HTTPS orqali yuborilmoqda).

   • : example.com (ma'lumot so'ralayotgan serverning manzili).

   • : /resource (ushbu manzil bo'yicha resurs so'ralmoqda).

   • accept: image/jpeg (mijoz serverdan JPEG formatidagi rasm so'ramoqda).

   • user-agent: Mozilla/5.0... (mijozning ishlatayotgan qurilmasi yoki brauzeri haqida ma'lumot).

2. Ushbu header'larning barchasi siqiladi va HEADERS frame (Stream 1) orqali serverga yuboriladi. Bu siqish jarayoni HTTP/2 protokolining muhim afzalliklaridan biri bo'lib, bu orqali tarmoq trafigi kamayadi.

Request #2 (Ikkinchi so'rov): Faqat o'zgargan qismi yuboriladi

1. Ikkinchi so'rovda ko'p ma'lumotlar birinchi so'rov bilan bir xil bo'lgani uchun, HTTP/2 ularni takroran yubormaydi.

   • : GET,: https,: example.com, accept: image/jpeg, user-agent: Mozilla/5.0 – bu qismlar o'zgarmagan va ular qaytadan yuborilmaydi. Ular implicit, ya'ni avtomatik ravishda birinchi so'rovdan olinadi.

2. O'zgargan qism esa faqat:

   • : /new_resource – bu faqatgina yangi resursga kirish uchun yangi URL manzili (eski /resource o'rniga).

3. Faqat o'zgargan qismlar siqilgan holda HEADERS frame (Stream 3) orqali yuboriladi. Bunda tarmoq trafigi optimallashtiriladi, ya'ni vaqt va resurslar tejaydi.

Nima sodir bo'lmoqda ?

1. Birinchi so'rovda barcha header'lar yuboriladi, chunki bu birinchi marta so'rov yuborilyapti va serverga ma'lumotlar kerak.

2. Ikkinchi so'rovda esa faqat o'zgargan qism yuboriladi (masalan, faqat yangi URL manzili), qolgan qismlar avtomatik ravishda birinchi so'rovdan olinadi.

Nima uchun bu muhim ?

• HTTP/1.1 bilan solishtirganda, HTTP/2-da ma'lumotni takroran yuborish o'rniga faqat zarur bo'lgan o'zgartirilgan qismlarni yuborish imkoniyati mavjud. Bu tarmoqlardagi ma'lumot oqimini kamaytiradi va serverlar bilan tezroq aloqa qilish imkonini beradi.

• Ko'p hollarda veb-brauzerlar yoki mijozlar serverga ko'p so'rovlar yuborishadi, va ular ko'pincha bir xil ma'lumotlarni yuboradi. HTTP/2 faqat o'zgargan qismlarini yuborib, resurslar tejashga imkon beradi.

Umumiy jarayon:

1. Birinchi so'rovda barcha kerakli ma'lumotlar to'liq yuboriladi.

2. Keyingi so'rovlar o'xshash bo'lsa, faqat yangi yoki o'zgargan qismlar yuboriladi, qolgan qismlar esa avtomatik ravishda avvalgi so'rovdan olinadi.

Ushbu jarayon HTTP/2 protokolining asosiy afzalliklaridan biri hisoblanadi va server bilan mijoz o'rtasidagi so'rov-javob jarayonini sezilarli darajada optimallashtiradi.

Xulosa:

HTTP/2 protokoli veb-so'rovlar va server javoblarining samaradorligini oshirish uchun siqish va takroran yubormaslik usulidan foydalanadi. Bu rasmda, faqat o'zgargan header'lar yuborilishi orqali tarmoq resurslaridan samarali foydalanish tushuntirilgan.

Linuxda Python va HTTP so'rovlarini yuborish

Linux operatsion tizimida HTTP so'rovlarini yuborish uchun Pythonning asosiy kutubxonasi hisoblangan requests kutubxonasidan foydalanamiz. Ushbu kutubxona HTTP va HTTPS so'rovlarini jo'natish va tahlil qilish uchun juda qulay.

Python yordamida HTTP so'rovlarini skanerlash: Amaliy misol

1. Linuxda Python requests kutubxonasini o'rnatish Agar requests kutubxonasi o'rnatilmagan bo'lsa, quyidagi buyruq orqali uni o'rnatishingiz mumkin:

   sudo pip install requests

2. HTTP so'rovini jo'natish va javobni tahlil qilish Quyida Python yordamida veb-saytga HTTP so'rovini yuborish va javobni qayta ishlashni ko'rsatuvchi misol keltirilgan:

   import requests
   
   # HTTP GET so'rovini yuborish
   url = "https://example.com"
   response = requests.get(url)
   
   # Javob kodini tekshirish
   print(f"Javob kodi: {response.status_code}")
   
   # Javob sarlavhalarini chop etish
   print("Javob sarlavhalari:")
   for key, value in response.headers.items():
       print(f"{key}: {value}")
   
   # Javobning birinchi 500 belgisi
   print("\nJavob matni:")
   print(response.text[:500])  # faqatgina birinchi 500 belgini chop qilish

3. Bir nechta HTTP metodlardan foydalanish Quyidagi misolda GET, POST, PUT va DELETE so'rovlarining qanday yuborilishini ko'rib chiqamiz:

   # GET so'rovi
   response_get = requests.get(url)
   print(f"GET so'rov status kodi: {response_get.status_code}")
   
   # POST so'rovi
   data = {"name": "John", "age": 30}
   response_post = requests.post(url, data=data)
   print(f"POST so'rov status kodi: {response_post.status_code}")
   
   # PUT so'rovi
   response_put = requests.put(url, data={"name": "John Updated"})
   print(f"PUT so'rov status kodi: {response_put.status_code}")
   
   # DELETE so'rovi
   response_delete = requests.delete(url)
   print(f"DELETE so'rov status kodi: {response_delete.status_code}")

4. Serverni skanerlash va zaifliklarni aniqlash Quyidagi kod veb-saytni ko'plab turli xil yo'nalishlar (paths) bo'yicha skanerlash va mavjudligini tekshirish uchun ishlatiladi. Bu veb-serverda mavjud bo'lgan zaif fayllar yoki sahifalarni topishga yordam beradi.

   import requests
   
   # Skaner qilinadigan URL
   target_url = "https://example.com"
   
   # Sinovdan o'tkaziladigan yo'llar
   paths = ["/admin", "/login", "/dashboard", "/config", "/robots.txt"]
   
   for path in paths:
       full_url = target_url + path
       response = requests.get(full_url)
       
       # Faqat mavjud sahifalar yoki ruxsat berilmagan sahifalarni ko'rsatish
       if response.status_code == 200:
           print(f"Mavjud: {full_url} (Status kodi: {response.status_code})")
       elif response.status_code == 403:
           print(f"Ruxsat berilmagan: {full_url} (Status kodi: {response.status_code})")
       elif response.status_code == 404:
           print(f"Topilmadi: {full_url} (Status kodi: {response.status_code})")
       else:
           print(f"{full_url} - Javob kodi: {response.status_code}")

5. HTTPS sertifikatini tekshirish HTTPS sertifikatlarining amal qilish muddatini yoki ularning haqiqiyligini tekshirish uchun Python-dan foydalanish mumkin. Quyidagi misol orqali HTTPS sertifikatni qanday tahlil qilish mumkinligi ko'rsatilgan:

   import requests
   
   url = "https://example.com"
   
   try:
       response = requests.get(url, verify=True)
       print(f"SSL sertifikat tekshirildi: {response.status_code}")
   except requests.exceptions.SSLError as e:
       print("SSL xatosi:", e)

6. Proxy orqali so'rov yuborish Ba'zida HTTP so'rovlarini yuborishda proxy serverlardan foydalanish talab qilinishi mumkin. Quyidagi misolda HTTP so'rovlarini proxy orqali yuborish ko'rsatilgan:

   proxies = {
       "http": "http://proxy.example.com:8080",
       "https": "https://proxy.example.com:8080"
   }
   
   response = requests.get("https://example.com", proxies=proxies)
   print(f"Proxy orqali yuborilgan javob kodi: {response.status_code}")

Amaliy qo'llanilishi:

1. Zaifliklarni aniqlash: Yuqoridagi skanerlash texnikalaridan foydalanib, siz server yoki API-da zaif yo'nalishlarni (paths), ochiq admin sahifalarni yoki noto'g'ri sozlangan sahifalarni aniqlashingiz mumkin.

2. Xavfsizlik tekshiruvi: SSL sertifikatlarni tekshirish, foydalanuvchi ruxsatini tekshirish (403 Forbidden), mavjud bo'lmagan sahifalar (404 Not Found) orqali sayt xavfsizligini tahlil qilish.

3. Brute Force sinovlari: Ko'p yo'llarni avtomatik ravishda skanerlash orqali veb-saytning noto'g'ri konfiguratsiyalarini topish.

Quyidagi Python kodi yordamida veb-sayt yoki API ga HTTP so‘rovi yuborish, javob kodini olish va uni tahlil qilish jarayonini ko‘rib chiqamiz. Keling, kodni har bir qatorini mayda qilib tushuntirib chiqamiz.

Python Kod:

import requests

# HTTP GET so'rovini yuborish
url = "https://example.com"
response = requests.get(url)

# Javob kodini tekshirish
print(f"Javob kodi: {response.status_code}")
   
# Javob sarlavhalarini chop etish
print("Javob sarlavhalari:")
for key, value in response.headers.items():
    print(f"{key}: {value}")
   
# Javobning birinchi 500 belgisi
print("\nJavob matni:")
print(response.text[:500])  # faqatgina birinchi 500 belgini chop qilish

1 import requests

Tushuntirish: Bu qator orqali biz Python'dagi requests kutubxonasini import qilamiz. requests — bu HTTP so'rovlarini yuborish va javoblarni tahlil qilish uchun ishlatiladigan eng mashhur kutubxonalardan biri. Ushbu kutubxona yordamida GET, POST, PUT, DELETE kabi so'rovlarni oson amalga oshirish mumkin.

Jarayon:

• Python interpreteri requests kutubxonasini xotiraga yuklaydi va keyinroq biz uni HTTP so'rovlarini yuborish uchun ishlatamiz.

2 url = "https://example.com"

Tushuntirish: Bu qator orqali biz HTTP so'rovini yubormoqchi bo'lgan URL manzilini url o'zgaruvchisiga saqlaymiz. Ushbu misolda, bizning URL manzilimiz "https://example.com", lekin amaliyotda siz haqiqiy sayt yoki API manzilini ishlatishingiz mumkin.

Jarayon:

• URL manzili dasturda ishlatiladigan url o'zgaruvchisida saqlanadi. Keyinchalik bu o'zgaruvchi orqali HTTP so'rov yuboramiz.

3 response = requests.get(url)

Tushuntirish: Bu qatorda requests.get() funksiyasi orqali URL manziliga HTTP GET so'rovi yuboramiz. Bu funksiya veb-serverga so'rov yuboradi va undan javobni qaytaradi. Kiritilgan URL (https://example.com) ga GET so'rovi yuboriladi va serverdan kelgan javob response o'zgaruvchisida saqlanadi.

Jarayon:

• requests.get(url) veb-serverga GET so'rovini yuboradi.

• So'rov yuborilganidan keyin server javob yuboradi (bu javob status kodi, sarlavhalar, va HTML kodlarni o'z ichiga olishi mumkin).

• Serverdan kelgan javobning barcha ma'lumotlari (response) o'zgaruvchisida saqlanadi.

4 print(f"Javob kodi: {response.status_code}")

Tushuntirish: Bu qatorda serverdan kelgan javobning status kodini chop etamiz. Status kodi serverning javobiga qarab turli raqamlar ko‘rinishida bo‘lishi mumkin, masalan:

• 200: Muvaffaqiyatli so'rov (OK)

• 404: Sahifa topilmadi (Not Found)

• 500: Server xatosi (Internal Server Error)

response.status_code orqali status kodini olish mumkin.

Jarayon:

• response.status_code yordamida biz serverdan qaytgan javobning status kodini olamiz.

• Bu status kodini print() yordamida foydalanuvchiga chop etamiz.

5 print("Javob sarlavhalari:")

Tushuntirish: Bu qatorda biz javobning sarlavhalari haqida ma'lumot chop etishni boshlaymiz. Javob sarlavhalari serverning javobida qanday ma'lumotlar mavjudligi haqida qo'shimcha ma'lumot beradi (masalan, kontent turi, kodlash turi va boshqa meta-ma'lumotlar).

Jarayon:

• Bu qator faqat sarlavhalar qismini chop qilishni boshlash uchun qo‘llanadi. Quyidagi qatorlarda esa sarlavhalar o'zlari chop qilinadi.

6 for key, value in response.headers.items():

Tushuntirish: Bu qatorda biz response.headers (serverdan kelgan javobning sarlavhalari) yordamida barcha header elementlarini tahlil qilamiz. response.headers lug'at (dictionary) shaklida bo'lib, unda har bir sarlavhaning nomi (key) va qiymati (value) mavjud. items() metodi orqali biz lug‘at ichidagi barcha elementlarni juftlikda olib chiqamiz.

Jarayon:

• response.headers.items() orqali barcha sarlavha (header) juftliklari (kalit-qiymat juftligi) olinadi.

• Har bir sarlavha uchun for-sikl ishlatiladi va kalit (header nomi) va qiymat (header qiymati) ajratiladi.

7 print(f"{key}: {value}")

Tushuntirish: Bu qatorda biz yuqorida aytilgan key va value (header nomi va qiymati) ni chop etamiz. Har bir sarlavha o'zining nomi va qiymati bilan ekranga chiqariladi.

Jarayon:

• Har bir key va value juftligi foydalanuvchiga chop etiladi.

• Masalan, Content-Type: text/html, Server: Apache kabi sarlavhalar ekranda ko'rinadi.

8 print("\nJavob matni:")

Tushuntirish: Bu qatorda biz foydalanuvchiga javobning asosiy matn qismini chop etishni boshlaymiz. Javobning matni (web-sahifaning HTML kodi yoki API javobi) response.text o'zgaruvchisi yordamida olinadi.

Jarayon:

• Bu qator foydalanuvchiga javob matnini ko'rsatishdan oldin chop etiladi.

9 print(response.text[:500])

Tushuntirish: Bu qatorda biz response.text (serverdan kelgan to'liq matnli javob, masalan, HTML yoki JSON) ni chop etamiz. Lekin biz faqat matnning birinchi 500 ta belgisini chop etamiz. Bu bilan javobning katta qismini chop qilmasdan faqat birinchi qismini ko'rsatamiz.

Jarayon:

• response.text matnni qaytaradi (masalan, HTML kodlari yoki JSON ma'lumotlar).

• [:500] matnning faqatgina birinchi 500 ta belgisini oladi.

• print() funksiyasi orqali bu matn ekranga chiqariladi.

Xulosa:

Ushbu Python kodi yordamida HTTP so'rovini yuborish, server javobini olish va javobni tahlil qilish jarayonini ko'rib chiqdik. Linux muhitida bu kodni ishlatish orqali turli saytlar yoki API-larga HTTP so'rovlari yuborishingiz va serverdan qaytgan javoblarni tahlil qilishingiz mumkin. Bu jarayon veb-sayt xavfsizligini tekshirish, zaifliklarni tahlil qilish yoki API-larni avtomatlashtirilgan tarzda boshqarish uchun juda foydali.