Deploy from GitHub repository

GhostTR.py

@@ -0,0 +1,315 @@
+#!/usr/bin/python
+# << CODE BY HUNX04
+# << MAU RECODE ??? IZIN DULU LAH,  MINIMAL TAG AKUN GITHUB MIMIN YANG MENGARAH KE AKUN INI, LEBIH GAMPANG SI PAKE FORK
+# << KALAU DI ATAS TIDAK DI IKUTI MAKA AKAN MENDAPATKAN DOSA KARENA MIMIN GAK IKHLAS
+# “Wahai orang-orang yang beriman! Janganlah kamu saling memakan harta sesamamu dengan jalan yang batil,” (QS. An Nisaa': 29). Rasulullah SAW juga melarang umatnya untuk mengambil hak orang lain tanpa izin.
+
+# IMPORT MODULE
+
+import json
+import requests
+import time
+import os
+import phonenumbers
+from phonenumbers import carrier, geocoder, timezone
+from sys import stderr
+
+Bl = '\033[30m'  # VARIABLE BUAT WARNA CUYY
+Re = '\033[1;31m'
+Gr = '\033[1;32m'
+Ye = '\033[1;33m'
+Blu = '\033[1;34m'
+Mage = '\033[1;35m'
+Cy = '\033[1;36m'
+Wh = '\033[1;37m'
+
+
+# utilities
+
+# decorator for attaching run_banner to a function
+def is_option(func):
+    def wrapper(*args, **kwargs):
+        run_banner()
+        func(*args, **kwargs)
+
+
+    return wrapper
+
+
+# FUNCTIONS FOR MENU
+@is_option
+def IP_Track():
+    ip = input(f"{Wh}\n Enter IP target : {Gr}")  # INPUT IP ADDRESS
+    print()
+    print(f' {Wh}============= {Gr}SHOW INFORMATION IP ADDRESS {Wh}=============')
+    req_api = requests.get(f"http://ipwho.is/{ip}")  # API IPWHOIS.IS
+    ip_data = json.loads(req_api.text)
+    time.sleep(2)
+    print(f"{Wh}\n IP target       :{Gr}", ip)
+    print(f"{Wh} Type IP         :{Gr}", ip_data["type"])
+    print(f"{Wh} Country         :{Gr}", ip_data["country"])
+    print(f"{Wh} Country Code    :{Gr}", ip_data["country_code"])
+    print(f"{Wh} City            :{Gr}", ip_data["city"])
+    print(f"{Wh} Continent       :{Gr}", ip_data["continent"])
+    print(f"{Wh} Continent Code  :{Gr}", ip_data["continent_code"])
+    print(f"{Wh} Region          :{Gr}", ip_data["region"])
+    print(f"{Wh} Region Code     :{Gr}", ip_data["region_code"])
+    print(f"{Wh} Latitude        :{Gr}", ip_data["latitude"])
+    print(f"{Wh} Longitude       :{Gr}", ip_data["longitude"])
+    lat = int(ip_data['latitude'])
+    lon = int(ip_data['longitude'])
+    print(f"{Wh} Maps            :{Gr}", f"https://www.google.com/maps/@{lat},{lon},8z")
+    print(f"{Wh} EU              :{Gr}", ip_data["is_eu"])
+    print(f"{Wh} Postal          :{Gr}", ip_data["postal"])
+    print(f"{Wh} Calling Code    :{Gr}", ip_data["calling_code"])
+    print(f"{Wh} Capital         :{Gr}", ip_data["capital"])
+    print(f"{Wh} Borders         :{Gr}", ip_data["borders"])
+    print(f"{Wh} Country Flag    :{Gr}", ip_data["flag"]["emoji"])
+    print(f"{Wh} ASN             :{Gr}", ip_data["connection"]["asn"])
+    print(f"{Wh} ORG             :{Gr}", ip_data["connection"]["org"])
+    print(f"{Wh} ISP             :{Gr}", ip_data["connection"]["isp"])
+    print(f"{Wh} Domain          :{Gr}", ip_data["connection"]["domain"])
+    print(f"{Wh} ID              :{Gr}", ip_data["timezone"]["id"])
+    print(f"{Wh} ABBR            :{Gr}", ip_data["timezone"]["abbr"])
+    print(f"{Wh} DST             :{Gr}", ip_data["timezone"]["is_dst"])
+    print(f"{Wh} Offset          :{Gr}", ip_data["timezone"]["offset"])
+    print(f"{Wh} UTC             :{Gr}", ip_data["timezone"]["utc"])
+    print(f"{Wh} Current Time    :{Gr}", ip_data["timezone"]["current_time"])
+
+
+@is_option
+def phoneGW():
+    User_phone = input(
+        f"\n {Wh}Enter phone number target {Gr}Ex [+6281xxxxxxxxx] {Wh}: {Gr}")  # INPUT NUMBER PHONE
+    default_region = "ID"  # DEFAULT NEGARA INDONESIA
+
+    parsed_number = phonenumbers.parse(User_phone, default_region)  # VARIABLE PHONENUMBERS
+    region_code = phonenumbers.region_code_for_number(parsed_number)
+    jenis_provider = carrier.name_for_number(parsed_number, "en")
+    location = geocoder.description_for_number(parsed_number, "id")
+    is_valid_number = phonenumbers.is_valid_number(parsed_number)
+    is_possible_number = phonenumbers.is_possible_number(parsed_number)
+    formatted_number = phonenumbers.format_number(parsed_number, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
+    formatted_number_for_mobile = phonenumbers.format_number_for_mobile_dialing(parsed_number, default_region,
+                                                                                with_formatting=True)
+    number_type = phonenumbers.number_type(parsed_number)
+    timezone1 = timezone.time_zones_for_number(parsed_number)
+    timezoneF = ', '.join(timezone1)
+
+    print(f"\n {Wh}========== {Gr}SHOW INFORMATION PHONE NUMBERS {Wh}==========")
+    print(f"\n {Wh}Location             :{Gr} {location}")
+    print(f" {Wh}Region Code          :{Gr} {region_code}")
+    print(f" {Wh}Timezone             :{Gr} {timezoneF}")
+    print(f" {Wh}Operator             :{Gr} {jenis_provider}")
+    print(f" {Wh}Valid number         :{Gr} {is_valid_number}")
+    print(f" {Wh}Possible number      :{Gr} {is_possible_number}")
+    print(f" {Wh}International format :{Gr} {formatted_number}")
+    print(f" {Wh}Mobile format        :{Gr} {formatted_number_for_mobile}")
+    print(f" {Wh}Original number      :{Gr} {parsed_number.national_number}")
+    print(
+        f" {Wh}E.164 format         :{Gr} {phonenumbers.format_number(parsed_number, phonenumbers.PhoneNumberFormat.E164)}")
+    print(f" {Wh}Country code         :{Gr} {parsed_number.country_code}")
+    print(f" {Wh}Local number         :{Gr} {parsed_number.national_number}")
+    if number_type == phonenumbers.PhoneNumberType.MOBILE:
+        print(f" {Wh}Type                 :{Gr} This is a mobile number")
+    elif number_type == phonenumbers.PhoneNumberType.FIXED_LINE:
+        print(f" {Wh}Type                 :{Gr} This is a fixed-line number")
+    else:
+        print(f" {Wh}Type                 :{Gr} This is another type of number")
+
+
+@is_option
+def TrackLu():
+    try:
+        username = input(f"\n {Wh}Enter Username : {Gr}")
+        results = {}
+        social_media = [
+            {"url": "https://www.facebook.com/{}", "name": "Facebook"},
+            {"url": "https://www.twitter.com/{}", "name": "Twitter"},
+            {"url": "https://www.instagram.com/{}", "name": "Instagram"},
+            {"url": "https://www.linkedin.com/in/{}", "name": "LinkedIn"},
+            {"url": "https://www.github.com/{}", "name": "GitHub"},
+            {"url": "https://www.pinterest.com/{}", "name": "Pinterest"},
+            {"url": "https://www.tumblr.com/{}", "name": "Tumblr"},
+            {"url": "https://www.youtube.com/{}", "name": "Youtube"},
+            {"url": "https://soundcloud.com/{}", "name": "SoundCloud"},
+            {"url": "https://www.snapchat.com/add/{}", "name": "Snapchat"},
+            {"url": "https://www.tiktok.com/@{}", "name": "TikTok"},
+            {"url": "https://www.behance.net/{}", "name": "Behance"},
+            {"url": "https://www.medium.com/@{}", "name": "Medium"},
+            {"url": "https://www.quora.com/profile/{}", "name": "Quora"},
+            {"url": "https://www.flickr.com/people/{}", "name": "Flickr"},
+            {"url": "https://www.periscope.tv/{}", "name": "Periscope"},
+            {"url": "https://www.twitch.tv/{}", "name": "Twitch"},
+            {"url": "https://www.dribbble.com/{}", "name": "Dribbble"},
+            {"url": "https://www.stumbleupon.com/stumbler/{}", "name": "StumbleUpon"},
+            {"url": "https://www.ello.co/{}", "name": "Ello"},
+            {"url": "https://www.producthunt.com/@{}", "name": "Product Hunt"},
+            {"url": "https://www.snapchat.com/add/{}", "name": "Snapchat"},
+            {"url": "https://www.telegram.me/{}", "name": "Telegram"},
+            {"url": "https://www.weheartit.com/{}", "name": "We Heart It"}
+        ]
+        for site in social_media:
+            url = site['url'].format(username)
+            response = requests.get(url)
+            if response.status_code == 200:
+                results[site['name']] = url
+            else:
+                results[site['name']] = (f"{Ye}Username not found {Ye}!")
+    except Exception as e:
+        print(f"{Re}Error : {e}")
+        return
+
+    print(f"\n {Wh}========== {Gr}SHOW INFORMATION USERNAME {Wh}==========")
+    print()
+    for site, url in results.items():
+        print(f" {Wh}[ {Gr}+ {Wh}] {site} : {Gr}{url}")
+
+
+@is_option
+def showIP():
+    respone = requests.get('https://api.ipify.org/')
+    Show_IP = respone.text
+
+    print(f"\n {Wh}========== {Gr}SHOW INFORMATION YOUR IP {Wh}==========")
+    print(f"\n {Wh}[{Gr} + {Wh}] Your IP Adrress : {Gr}{Show_IP}")
+    print(f"\n {Wh}==============================================")
+
+
+# OPTIONS
+options = [
+    {
+        'num': 1,
+        'text': 'IP Tracker',
+        'func': IP_Track
+    },
+    {
+        'num': 2,
+        'text': 'Show Your IP',
+        'func': showIP
+
+    },
+    {
+        'num': 3,
+        'text': 'Phone Number Tracker',
+        'func': phoneGW
+    },
+    {
+        'num': 4,
+        'text': 'Username Tracker',
+        'func': TrackLu
+    },
+    {
+        'num': 0,
+        'text': 'Exit',
+        'func': exit
+    }
+]
+
+
+def clear():
+    # for windows
+    if os.name == 'nt':
+        _ = os.system('cls')
+    # for mac and linux
+    else:
+        _ = os.system('clear')
+
+
+def call_option(opt):
+    if not is_in_options(opt):
+        raise ValueError('Option not found')
+    for option in options:
+        if option['num'] == opt:
+            if 'func' in option:
+                option['func']()
+            else:
+                print('No function detected')
+
+
+def execute_option(opt):
+    try:
+        call_option(opt)
+        input(f'\n{Wh}[ {Gr}+ {Wh}] {Gr}Press enter to continue')
+        main()
+    except ValueError as e:
+        print(e)
+        time.sleep(2)
+        execute_option(opt)
+    except KeyboardInterrupt:
+        print(f'\n{Wh}[ {Re}! {Wh}] {Re}Exit')
+        time.sleep(2)
+        exit()
+
+
+def option_text():
+    text = ''
+    for opt in options:
+        text += f'{Wh}[ {opt["num"]} ] {Gr}{opt["text"]}\n'
+    return text
+
+
+def is_in_options(num):
+    for opt in options:
+        if opt['num'] == num:
+            return True
+    return False
+
+
+def option():
+    # BANNER TOOLS
+    clear()
+    stderr.writelines(f"""
+       ________               __      ______                __  
+      / ____/ /_  ____  _____/ /_    /_  __/________ ______/ /__
+     / / __/ __ \/ __ \/ ___/ __/_____/ / / ___/ __ `/ ___/ //_/
+    / /_/ / / / / /_/ (__  ) /_/_____/ / / /  / /_/ / /__/ ,<   
+    \____/_/ /_/\____/____/\__/     /_/ /_/   \__,_/\___/_/|_| 
+
+              {Wh}[ + ]  C O D E   B Y  H U N X  [ + ]
+    """)
+
+    stderr.writelines(f"\n\n\n{option_text()}")
+
+
+def run_banner():
+    clear()
+    time.sleep(1)
+    stderr.writelines(f"""{Wh}
+         .-.
+       .'   `.          {Wh}--------------------------------
+       :g g   :         {Wh}| {Gr}GHOST - TRACKER - IP ADDRESS {Wh}|
+       : o    `.        {Wh}|       {Gr}@CODE BY HUNXBYTS      {Wh}|
+      :         ``.     {Wh}--------------------------------
+     :             `.
+    :  :         .   `.
+    :   :          ` . `.
+     `.. :            `. ``;
+        `:;             `:'
+           :              `.
+            `.              `.     .
+              `'`'`'`---..,___`;.-'
+        """)
+    time.sleep(0.5)
+
+
+def main():
+    clear()
+    option()
+    time.sleep(1)
+    try:
+        opt = int(input(f"{Wh}\n [ + ] {Gr}Select Option : {Wh}"))
+        execute_option(opt)
+    except ValueError:
+        print(f'\n{Wh}[ {Re}! {Wh}] {Re}Please input number')
+        time.sleep(2)
+        main()
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except KeyboardInterrupt:
+        print(f'\n{Wh}[ {Re}! {Wh}] {Re}Exit')
+        time.sleep(2)
+        exit()

README.md

@@ -1,12 +1,16 @@
 ---
 title: Ghosttrack
-emoji: 👁
-colorFrom: gray
-colorTo: purple
+emoji: 🚀
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 5.44.1
+sdk_version: "5.35.0"
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Ghosttrack
+
+Useful tool to track location or mobile number, so this tool can be called osint or also information gathering
+
+Deployed from: https://github.com/seawolf2357/GhostTrack

app.py

@@ -0,0 +1,137 @@
+import gradio as gr
+import requests
+import phonenumbers
+from phonenumbers import geocoder, carrier, timezone
+import json
+
+def track_ip(ip_address):
+    try:
+        response = requests.get(f"http://ip-api.com/json/{ip_address}")
+        data = response.json()
+        
+        if data['status'] == 'success':
+            result = f"""IP Tracking Results:
+Country: {data['country']}
+Region: {data['regionName']}
+City: {data['city']}
+ZIP: {data['zip']}
+Latitude: {data['lat']}
+Longitude: {data['lon']}
+ISP: {data['isp']}
+Organization: {data['org']}
+AS: {data['as']}"""
+            return result
+        else:
+            return "Error: Invalid IP address or tracking failed."
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def track_phone(phone_number):
+    try:
+        # Parse the phone number
+        parsed_number = phonenumbers.parse(phone_number, None)
+        
+        # Validate the phone number
+        if not phonenumbers.is_valid_number(parsed_number):
+            return "Error: Invalid phone number."
+        
+        # Get location
+        location = geocoder.description_for_number(parsed_number, "en")
+        
+        # Get carrier
+        carrier_name = carrier.name_for_number(parsed_number, "en")
+        
+        # Get timezone
+        timezones = timezone.time_zones_for_number(parsed_number)
+        
+        # Check if number is valid
+        is_valid = phonenumbers.is_valid_number(parsed_number)
+        
+        # Check if number is possible
+        is_possible = phonenumbers.is_possible_number(parsed_number)
+        
+        result = f"""Phone Tracking Results:
+Number: {phone_number}
+Valid: {is_valid}
+Possible: {is_possible}
+Location: {location}
+Carrier: {carrier_name}
+Timezones: {', '.join(timezones)}"""
+        
+        return result
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def track_username(username):
+    try:
+        # List of social media platforms to check
+        platforms = {
+            "GitHub": f"https://github.com/{username}",
+            "Twitter": f"https://twitter.com/{username}",
+            "Instagram": f"https://instagram.com/{username}",
+            "Reddit": f"https://reddit.com/user/{username}",
+            "Facebook": f"https://facebook.com/{username}",
+        }
+        
+        results = []
+        for platform, url in platforms.items():
+            try:
+                response = requests.get(url, timeout=5)
+                if response.status_code == 200:
+                    results.append(f"{platform}: Found - {url}")
+                else:
+                    results.append(f"{platform}: Not Found")
+            except:
+                results.append(f"{platform}: Not Found")
+        
+        return "\n".join(results)
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+with gr.Blocks(title="GhostTrack - OSINT Tool") as demo:
+    gr.Markdown("""
+    # GhostTrack - OSINT Information Gathering Tool
+    
+    Useful tool to track location or mobile number. This tool can be used for OSINT (Open Source Intelligence) and information gathering.
+    """)
+    
+    with gr.Tab("IP Tracker"):
+        gr.Markdown("""
+        ### IP Address Tracker
+        
+        Enter an IP address to get geolocation and ISP information.
+        """)
+        ip_input = gr.Textbox(label="IP Address", placeholder="Enter IP address (e.g., 8.8.8.8)")
+        ip_output = gr.Textbox(label="Tracking Results", lines=12)
+        ip_button = gr.Button("Track IP")
+        ip_button.click(fn=track_ip, inputs=ip_input, outputs=ip_output)
+    
+    with gr.Tab("Phone Tracker"):
+        gr.Markdown("""
+        ### Phone Number Tracker
+        
+        Enter a phone number with country code to get location and carrier information.
+        """)
+        phone_input = gr.Textbox(label="Phone Number", placeholder="Enter phone number with country code (e.g., +1234567890)")
+        phone_output = gr.Textbox(label="Tracking Results", lines=12)
+        phone_button = gr.Button("Track Phone")
+        phone_button.click(fn=track_phone, inputs=phone_input, outputs=phone_output)
+    
+    with gr.Tab("Username Tracker"):
+        gr.Markdown("""
+        ### Username Tracker
+        
+        Enter a username to check its presence on various social media platforms.
+        """)
+        username_input = gr.Textbox(label="Username", placeholder="Enter username (e.g., johnsmith)")
+        username_output = gr.Textbox(label="Tracking Results", lines=12)
+        username_button = gr.Button("Track Username")
+        username_button.click(fn=track_username, inputs=username_input, outputs=username_output)
+    
+    gr.Markdown("""
+    ---
+    **Note:** This tool is for educational purposes only. Please use responsibly and ethically.
+    """)
+
+if __name__ == "__main__":
+    demo.launch()

asset/text

@@ -0,0 +1 @@
+Image..

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=5.35.0
+phonenumbers
+requests