Forem: Bohdan Lukianets

How to Automate Developer OSINT with Python

Bohdan Lukianets — Mon, 03 Mar 2025 03:25:00 +0000

Hey Dev.to community! 👋

Last month, I had a surprising realization. While applying for a contract position, the client mentioned they'd already checked out several of my old Stack Overflow answers and even a GitHub issue I'd commented on two years ago. It got me thinking—just how visible is my digital footprint as a developer?

In this post, I'll show you how I built a simple Python tool leveraging Open Source Intelligence (OSINT) techniques to gather developer-related information from public sources. We'll use my own nickname "bohdanai" as a practical example.

📌 What is OSINT?

Open Source Intelligence (OSINT) refers to collecting and analyzing publicly available data. For developers, OSINT can help you quickly gather useful information such as GitHub profiles, LinkedIn profiles, open-source contributions, and professional activities.

🎯 Our Goal

We'll create a Python script that:

Accepts a developer's name or nickname.
Searches online sources like Google for mentions.
Extracts relevant LinkedIn and GitHub profile links.
Optionally scrapes specific websites for mentions.
Returns structured results for further analysis.

🛠️ Tools and Libraries Used:

requests — for sending HTTP requests.
BeautifulSoup — for parsing HTML content.
googlesearch-python — to perform Google searches directly from Python.

Install these libraries with:

pip install requests beautifulsoup4 googlesearch-python

## 🛠️ Tools and Libraries Used:

- `requests` — for sending HTTP requests.
- `BeautifulSoup` — for parsing HTML content.
- `googlesearch-python` — to perform Google searches directly from Python.

Install these libraries with:

bash
pip install requests beautifulsoup4 googlesearch-python

Hey Dev.to community! 👋

📌 What is OSINT?

Open Source Intelligence (OSINT) refers to collecting and analyzing publicly available data. For developers, OSINT can help you quickly gather useful information such as GitHub repositories, LinkedIn profiles, open-source contributions, and professional activities.

🎯 Our Goal

We'll create a Python script that:

Accepts a developer's name or nickname.
Searches online sources like Google for mentions.
Extracts relevant LinkedIn and GitHub profile links.
Optionally scrapes specific websites for mentions.
Returns structured results for further analysis.

🛠️ Tools and Libraries Used:

requests — for sending HTTP requests.
BeautifulSoup — for parsing HTML content.
googlesearch-python — to perform Google searches directly from Python.

Install these libraries with:

pip install requests beautifulsoup4 googlesearch-python

⚙️ Python Script Implementation

Here's the complete Python script:

import requests
from bs4 import BeautifulSoup
from googlesearch import search
import json

def search_developer(name, num_results=10, website_url=None):
    results = {
        "name": name,
        "google_results": [],
        "linkedin_url": None,
        "github_url": None,
        "website_mentions": []
    }

    # Google Search
    print(f"🔍 Searching Google for '{name}'...")
    try:
        for url in search(name, num=num_results, stop=num_results, pause=2):
            results["google_results"].append(url)
    except Exception as e:
        print(f"⚠️ Google search error: {e}")

    # LinkedIn URL extraction
    print("🔗 Extracting LinkedIn URL...")
    for url in results["google_results"]:
        if "linkedin.com/in/" in url:
            results["linkedin_url"] = url
            break

    # GitHub URL extraction
    print("🐱 Extracting GitHub URL...")
    for url in results["google_results"]:
        if "github.com" in url and "/issues" not in url and "/pull" not in url:
            results["github_url"] = url
            break

    # Optional: Website scraping
    if website_url:
        print(f"🌐 Scraping mentions from {website_url}...")
        try:
            response = requests.get(website_url, timeout=5)
            soup = BeautifulSoup(response.text, 'html.parser')
            texts = soup.stripped_strings
            for text in texts:
                if name.lower() in text.lower():
                    results["website_mentions"].append(text)
        except requests.RequestException as e:
            print(f"⚠️ Website scraping error: {e}")

    return results

def save_to_json(data, filename="osint_results.json"):
    with open(filename, 'w') as f:
        json.dump(data, f, indent=2)
    print(f"📁 Results saved to {filename}")

if __name__ == "__main__":
    developer_name = input("Enter developer name or username to research: ") or "bohdanai"
    my_website = "https://bohdanlukianets.pro"

    data = search_developer(developer_name, website_url=my_website)

    print("\n📋 --- OSINT Results ---")
    print(f"👤 Name/Nickname: {data['name']}")
    print(f"🔗 LinkedIn: {data.get('linkedin_url', 'Not found')}")
    print(f"🐙 GitHub: {data.get('github_url', 'Not found')}")

    print("\n🌍 Google Results:")
    for idx, url in enumerate(data["google_results"], start=1):
        print(f"{idx}. {url}")

    if data["website_mentions"]:
        print(f"\n🔖 Mentions on {my_website}:")
        for mention in data["website_mentions"]:
            print(f"- {mention}")
    else:
        print(f"\n🔖 No mentions found on {my_website}.")

    save_to_json(data)

🚀 Running the Script

Simply save the code above in a file called osint_script.py and run it:

python osint_script.py

You'll be prompted to enter a username or you can hit enter to use the default "bohdanai".

✅ Strengths of This Script:

Easy to Understand: Clear structure and inline comments.
Beginner-Friendly: Great introduction to web scraping and OSINT.
Basic Error Handling: Handles exceptions in requests and search operations.
Popular Libraries: Uses well-known and maintained Python libraries.

⚠️ Weaknesses & Points for Improvement:

Reliability: Google scraping might lead to temporary IP blocks.
Limited Personalization: Currently uses fixed URLs; consider adding custom inputs.
Ethical Concerns: Always ensure you have permission and follow ethical guidelines.
Output Format: Consider adding detailed CSV or Excel outputs for easier analysis.
Rate Limiting: Add delays (time.sleep()) for more extensive searches to avoid IP blocks.

🔐 Ethical Considerations:

Always respect privacy and legal frameworks when gathering personal data from the web. This script is intended purely for educational purposes and ethical OSINT investigations.

🧠 Lessons Learned & Practical Tips:

Google rate limits are real—use pauses between requests.
Always scrape responsibly to avoid getting IP-blocked.
Results vary widely based on online activity and SEO.

🔮 Where This Could Go Next:

Using official APIs instead of scraping.
Sentiment analysis on collected mentions.
Visualizing your digital presence.
Automated monitoring for new mentions.

🌐 Connect With Me:

Feel free to connect with me through these platforms:

🌐 Personal Website: bohdanlukianets.pro
💼 LinkedIn: linkedin.com/in/bohdanlukianets
🐙 GitHub: github.com/bohdanaims
📚 Dev.to: dev.to/bohdanaims

💬 Your Turn!

Have you checked your own digital footprint? Were you surprised by what you found? What enhancements or ideas would you like to see next? Let me know your thoughts in the comments!

Happy coding! 🌟👩‍💻👨‍💻

🔥 Ultimate Python Utilities Guide: 100 Essential Tools for Every Developer

Bohdan Lukianets — Wed, 13 Nov 2024 01:58:52 +0000

🔥 Ultimate Python Utilities Guide: 100 Essential Tools for Every Developer

By bohdan.AI | Last Updated: 2024

Introduction

Hey DEV community! 👋 I've compiled a comprehensive list of Python utilities that I use daily for development across different platforms. Each section includes practical code examples and real-world implementations.

iOS/iPhone Tools
macOS Development
Windows Utilities
Cross-Platform Tools
Installation Guide
Contributing

iOS/iPhone Tools

1. Photo Management Automation

from typing import List, Dict
import asyncio
import logging

class iOSPhotoManager:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.logger = logging.getLogger(__name__)

    async def batch_extract(self, directory: str) -> List[str]:
        """
        Bulk photo extraction with metadata preservation
        """
        try:
            photos = []
            # Implementation for photo extraction
            self.logger.info(f"Extracted {len(photos)} photos")
            return photos
        except Exception as e:
            self.logger.error(f"Extraction failed: {e}")
            return []

    async def process_backup(self, backup_path: str) -> Dict:
        """
        Advanced iOS backup parsing and analysis
        """
        return {
            'status': 'success',
            'files_processed': 100,
            'timestamp': '2024-01-15'
        }

2. Data Management

class iOSDataHandler:
    def merge_contacts(self, contacts: List[Dict]) -> List[Dict]:
        """
        Smart contact deduplication and merging
        """
        # Implementation
        return optimized_contacts

    def format_notes(self, notes: List[str]) -> List[str]:
        """
        Intelligent note formatting and organization
        """
        # Implementation
        return formatted_notes

macOS Development

1. System Optimization

import psutil
from pathlib import Path

class MacSystemOptimizer:
    def __init__(self):
        self.cache_paths = [
            Path.home() / 'Library' / 'Caches',
            Path('/Library/Caches'),
        ]

    def clean_system(self, aggressive: bool = False):
        """
        Intelligent system cleanup with safety checks
        """
        for path in self.cache_paths:
            if path.exists():
                # Implementation for safe cleanup
                pass

    async def monitor_performance(self) -> Dict:
        """
        Real-time system performance monitoring
        """
        return {
            'cpu': psutil.cpu_percent(),
            'memory': psutil.virtual_memory().percent,
            'disk': psutil.disk_usage('/').percent
        }

Cross-Platform Development Tools

1. Security Suite

from cryptography.fernet import Fernet
import hashlib
import os

class SecurityTools:
    def __init__(self):
        self.key = Fernet.generate_key()
        self.cipher_suite = Fernet(self.key)

    def encrypt_file(self, filepath: str) -> bool:
        """
        Secure file encryption with integrity checks
        """
        try:
            with open(filepath, 'rb') as file:
                file_data = file.read()
            encrypted_data = self.cipher_suite.encrypt(file_data)
            # Save encrypted data
            return True
        except Exception as e:
            logging.error(f"Encryption failed: {e}")
            return False

2. AI Developer Tools

import tensorflow as tf
import numpy as np

class AIDevTools:
    def enhance_code(self, code: str) -> str:
        """
        AI-powered code enhancement and optimization
        """
        # Implementation using transformer models
        return enhanced_code

    def analyze_performance(self, metrics: List[float]) -> Dict:
        """
        ML-based performance analysis
        """
        return {
            'trend': 'improving',
            'anomalies': [],
            'recommendations': []
        }

Installation Guide

# Create virtual environment
python -m venv venv
source venv/bin/activate  # Linux/Mac
.\venv\Scripts\activate   # Windows

# Install required packages
pip install -r requirements.txt

Required dependencies:

# requirements.txt
cryptography>=3.4.7
tensorflow>=2.8.0
psutil>=5.8.0
aiohttp>=3.8.1

Contributing

Want to contribute? Here's how:

Fork the repository
Create your feature branch (git checkout -b feature/AmazingFeature)
Commit your changes (git commit -m 'Add some AmazingFeature')
Push to the branch (git push origin feature/AmazingFeature)
Open a Pull Request

🔗 Connect With Me

LinkedIn: linkedin.in/bohdanai
GitHub: github.com/Bohdan-AI
Twitter: x.com/bohdanlukianets
DEV Community: @bohdanai

Wrapping Up

Found this useful? Let me know in the comments! And don't forget to:

🌟 Follow for more Python development tips
💖 Like if you found this helpful
🔖 Save for future reference

Happy coding! 🚀

This guide is regularly updated with new tools and code examples. Last updated: January 2024

Methods and Implementations of Single Sign-On (SSO)

Bohdan Lukianets — Thu, 07 Nov 2024 11:57:41 +0000

An In-Depth Exploration of SSO Techniques

Introduction

Single Sign-On (SSO) is a crucial authentication process that allows users to access multiple applications with one set of login credentials. It streamlines the user experience, enhances security, and simplifies the management of user identities across various platforms. This article delves into different methods and implementations of SSO, analyzing their security levels, complexities, and required components.

Basic SSO

Basic SSO employs Microsoft Entra ID and SAML (Security Assertion Markup Language) to achieve high security with minimal complexity. This method requires an Azure AD tenant, SAML configuration, and SSL certificates. Due to its straightforward implementation, Basic SSO is highly effective in environments where simplicity and security are paramount.

Multi-tenant SSO

Multi-tenant SSO uses Azure B2C (Business to Consumer) along with custom policies. It offers very high security, making it suitable for applications serving multiple tenants. Key components include the Azure B2C tenant, custom policies, and the Identity Experience Framework, ensuring a flexible and robust authentication system.

Hardware Key + SSO

Hardware Key + SSO incorporates hardware security keys to enhance the security of the SSO process. By utilizing physical keys, this method provides a strong defense against phishing attacks and unauthorized access.

Passwordless SSO

Passwordless SSO leverages FIDO2 authentication standards and Azure AD to provide very high security with medium complexity. It requires FIDO2 keys, Azure AD Premium, and modern browsers. This method eliminates the need for passwords, which are often weak and vulnerable, thereby significantly improving overall security.

B2B SSO

B2B SSO is specifically designed for business-to-business interactions. It utilizes Azure AD B2B and custom policies to ensure seamless partner integration. This approach prioritizes high-level security and customizability, making it essential for organizations working closely with external partners.

Step-Up Auth SSO

Step-Up Authentication with SSO combines Progressive Multi-Factor Authentication (MFA) with Azure AD to ensure very high security and usability. This method uses Azure AD Premium, multiple MFA providers, and risk policies to dynamically adjust authentication requirements based on user behavior and risk levels.

Just-In-Time SSO

Just-In-Time SSO integrates Privileged Identity Management (PIM) with Conditional Access policies to ensure timely access to resources. It offers very high security with high complexity, requiring components such as Azure AD PIM, Conditional Access policies, and approval flows.

Enterprise SSO

Enterprise SSO solutions include Okta with OpenID Connect (OIDC), providing very high security with medium complexity. Key components are the Okta tenant, OIDC integration, and custom domains. This method is ideal for large enterprises needing a scalable and secure SSO solution.

Federated SSO

Federated SSO uses Azure AD and Google Workspace to achieve high security with medium complexity. It involves setting up federation between different identity providers, ensuring seamless user access across various platforms.

Hybrid SSO

Hybrid SSO combines on-premise Active Directory (AD) with Azure AD, offering high security with high complexity. This method is suitable for organizations transitioning to cloud-based services while maintaining legacy systems.

Zero Trust SSO

Zero Trust SSO integrates Azure AD with Conditional Access policies, providing very high security with high complexity. It emphasizes continuous verification of user identities and device compliance, ensuring robust protection against threats.

Biometric + SSO

Biometric SSO utilizes Windows Hello and Azure AD, offering very high security with medium complexity. This method relies on biometric sensors and TPM chips, ensuring secure and user-friendly authentication.

Certificate-Based SSO

Certificate-Based SSO uses client certificates and Azure AD to achieve very high security with high complexity. It requires a Public Key Infrastructure (PKI), a certificate authority, and Azure AD, ensuring strong and reliable authentication.

Smart Card SSO

Smart Card SSO employs PIV (Personal Identity Verification) cards and Azure AD, providing extreme security with high complexity. It necessitates smart card readers, PIV cards, and Azure AD.

Mobile SSO

Mobile SSO uses Microsoft Authenticator and Azure AD to offer high security with low complexity. This method leverages mobile devices and the Authenticator app, providing a convenient and secure authentication process.

Multi-Factor SSO

Multi-Factor SSO combines MFA with Conditional Access policies, providing very high security with medium complexity. It requires Azure MFA, Conditional Access policies, and authentication apps, ensuring robust protection against unauthorized access.

Location-Based SSO

Location-Based SSO utilizes geo-fencing and Azure AD to achieve high security with medium complexity. It involves configuring named locations and IP ranges, ensuring that access is granted only from trusted locations.

Device-Based SSO

Device-Based SSO integrates Intune with Azure AD, offering high security with high complexity. This method requires Intune, Azure AD, and Mobile Device Management (MDM) policies, ensuring device compliance and secure access.

Risk-Based SSO

Risk-Based SSO uses Identity Protection and Azure AD to provide very high security with high complexity. It involves configuring risk policies and machine learning algorithms, dynamically adjusting authentication requirements based on risk levels.

Hybrid Cloud SSO

Hybrid Cloud SSO combines AWS Identity and Access Management (IAM) with Azure AD, offering high security with high complexity. It requires federation setup between AWS and Azure AD, ensuring seamless access across hybrid cloud environments.

Cross-Platform SSO

Cross-Platform SSO uses Azure AD and Apple Business Manager, providing high security with medium complexity. This method ensures secure access across different platforms, leveraging MDM solutions.

Token-Based SSO

Token-Based SSO employs JSON Web Tokens (JWT) and Azure AD to achieve high security with medium complexity. It involves setting up a token service and API management, ensuring secure and efficient authentication.

Adaptive SSO

Adaptive SSO integrates risk-based Conditional Access and Azure AD, offering very high security with high complexity. This method dynamically adjusts authentication requirements based on user behavior and risk levels.

Continuous Auth SSO

Continuous Auth SSO uses session risk and Azure AD to provide very high security with high complexity. It involves monitoring session policies and risk factors, ensuring continuous and adaptive authentication.

Zero Standing Access

Zero Standing Access combines Privileged Identity Management (PIM) with Azure AD, providing extreme security with high complexity. It requires JIT access and approval workflows, ensuring minimal standing privileges.

Attribute-Based SSO

Attribute-Based SSO uses Attribute-Based Access Control (ABAC) and Azure AD to achieve very high security with high complexity. It involves configuring custom attributes and policy engines, ensuring flexible and granular access control.

Role-Based SSO

Role-Based SSO employs Role-Based Access Control (RBAC) and Azure AD, offering high security with medium complexity. It involves defining roles and conducting access reviews, ensuring that users have appropriate access levels.

Time-Based SSO

Time-Based SSO uses temporal access policies and Azure AD, providing high security with medium complexity. It involves configuring time windows and access schedules, ensuring that access is granted only during specified times.

Network-Based SSO

Network-Based SSO integrates VPN solutions with Azure AD, offering high security with medium complexity. It requires VPN setup and network policies, ensuring that access is granted only from secure network environments.

Behavioral SSO

Behavioral SSO uses user behavior analytics and Azure AD to achieve very high security with high complexity. It involves monitoring behavioral patterns and employing machine learning models, ensuring adaptive and secure authentication.

Context-Aware SSO

Context-Aware SSO leverages environmental factors and Azure AD, providing very high security with high complexity. It involves configuring context engines and policy frameworks, ensuring that authentication requirements adapt to changing environmental conditions.

Delegated SSO

Delegated SSO employs admin delegation and Azure AD, offering high security with medium complexity. It involves configuring delegation policies and an RBAC model, ensuring that administrative tasks are securely delegated.

Emergency Access SSO

Emergency Access SSO combines break-glass accounts with Azure AD, providing very high security with medium complexity. It requires secure storage and audit logs, ensuring that emergency access is granted only under specific conditions.

Service Account SSO

Service Account SSO uses managed identities and Azure AD, offering high security with medium complexity. It involves configuring MSI support and key vaults, ensuring that service accounts have secure and seamless access.

Cloud App SSO

Cloud App SSO integrates app proxies with Azure AD, providing high security with medium complexity. It requires configuring app proxies and connector groups, ensuring secure access to cloud applications.

Legacy App SSO

Legacy App SSO uses password vaulting and Azure AD, offering medium security with medium complexity. It involves configuring password vaults and app templates, ensuring that legacy applications can securely integrate with modern SSO solutions.

Mobile App SSO

Mobile App SSO uses Mobile Application Management (MAM) and Azure AD, providing high security with high complexity. It involves configuring Intune MAM and app protection policies, ensuring secure access from mobile applications.

Browser-Based SSO

Browser-Based SSO employs Web Authentication (WebAuthN) and Azure AD, offering high security with low complexity. It requires modern browsers and WebAuthN support, ensuring that users can securely authenticate through web browsers.

Desktop SSO

Desktop SSO uses Windows Hello and Azure AD, providing high security with medium complexity. It involves configuring Windows 10/11, TPM chips, and Azure AD, ensuring secure authentication for desktop environments.

API SSO

API SSO integrates OAuth 2.0 with Azure AD, offering high security with medium complexity. It requires configuring OAuth setup and API management, ensuring secure and efficient authentication for API access.

Headless SSO

Headless SSO employs service principals and Azure AD, providing high security with medium complexity. It involves configuring certificate authentication and service principals, ensuring secure access for headless applications.

Container SSO

Container SSO uses managed identities and Azure Kubernetes Service (AKS), offering high security with high complexity. It involves configuring AKS and pod identities, ensuring secure authentication for containerized environments.

IoT SSO

IoT SSO integrates IoT Hub with Azure AD, providing high security with high complexity. It involves configuring IoT Hub and device provisioning, ensuring secure authentication for IoT devices.

Edge Computing SSO

Edge Computing SSO uses edge nodes and Azure AD, offering high security with high complexity. It involves configuring edge devices and local authentication, ensuring secure access for edge computing environments.

Hybrid Identity SSO

Hybrid Identity SSO employs password hash synchronization and Azure AD, providing high security with medium complexity. It involves configuring Azure AD Connect and password sync, ensuring seamless integration between on-premise and cloud identities.

Guest Access SSO

Guest Access SSO uses Azure AD B2B and custom authentication, offering high security with medium complexity. It involves configuring custom policies and guest access, ensuring secure authentication for external users.

Sovereign Cloud SSO

Sovereign Cloud SSO integrates national clouds with Azure AD, providing very high security with high complexity. It involves configuring sovereign Azure AD, compliance policies, and local datacenters, ensuring adherence to regional regulations.

Compliance-Based SSO

Compliance-Based SSO uses regulatory policies and Azure AD, offering very high security with high complexity. It involves configuring compliance policies and audit systems, ensuring that authentication processes meet regulatory requirements.

AI-Enhanced SSO

AI-Enhanced SSO employs machine learning models and Azure AD, providing very high security with very high complexity. It involves configuring AI models and behavioral data, ensuring that authentication processes adapt to evolving threats.

Zero-Knowledge SSO

Zero-Knowledge SSO uses end-to-end encryption and Azure AD, offering extreme security with very high complexity. It requires configuring encryption, key management, and Azure AD, ensuring that authentication data remains secure and private.

In conclusion, the diverse methods and implementations of SSO offer a range of security levels, complexities, and components to suit different organizational needs. By carefully selecting the appropriate SSO solution, organizations can enhance security, streamline user access, and improve overall efficiency.

Hi Community

Bohdan Lukianets — Thu, 03 Oct 2024 07:36:10 +0000

It is a privilege to be a part of such a robust community.

Forem: Bohdan Lukianets

How to Automate Developer OSINT with Python

📌 What is OSINT?

🎯 Our Goal

🛠️ Tools and Libraries Used:

📌 What is OSINT?

🎯 Our Goal

🛠️ Tools and Libraries Used:

⚙️ Python Script Implementation

🚀 Running the Script

✅ Strengths of This Script:

⚠️ Weaknesses & Points for Improvement:

🔐 Ethical Considerations:

🧠 Lessons Learned & Practical Tips:

🔮 Where This Could Go Next:

🌐 Connect With Me:

💬 Your Turn!

🔥 Ultimate Python Utilities Guide: 100 Essential Tools for Every Developer

🔥 Ultimate Python Utilities Guide: 100 Essential Tools for Every Developer

Introduction

Table of Contents

iOS/iPhone Tools

1. Photo Management Automation

2. Data Management

macOS Development

1. System Optimization

Cross-Platform Development Tools

1. Security Suite

2. AI Developer Tools

Installation Guide

Contributing

🔗 Connect With Me

Wrapping Up

Methods and Implementations of Single Sign-On (SSO)

Hi Community