Tag: #Utility

#!/usr/bin/env python3
import re
import getpass

def evaluate_password_strength(password):
    """
    Evaluate the password strength based on five criteria:
    - At least 8 characters long
    - Contains an uppercase letter
    - Contains a lowercase letter
    - Contains a digit
    - Contains a special character
    Additionally, the function checks for commonly used (and easily guessable) passwords.
    Returns a tuple containing the strength rating, score, and suggestions for improvement.
    """
    score = 0
    suggestions = []

    # Check for common (easily guessable) passwords
    common_passwords = {
        "password", "12345", "123456", "qwerty", "abc123",
        "111111", "123123", "password1", "letmein", "admin"
    }
    if password.lower() in common_passwords:
        suggestions.append("Your password is among the most commonly used and easily guessable passwords. Please choose a more unique password.")
        # Override the score for common passwords
        score = 0
        # Early return the evaluation since it's a significant security risk.
        return "Weak", score, suggestions

    # Check for minimum length
    if len(password) >= 8:
        score += 1
    else:
        suggestions.append("Make sure your password is at least 8 characters long.")

    # Check for uppercase letters
    if re.search(r'[A-Z]', password):
        score += 1
    else:
        suggestions.append("Include at least one uppercase letter.")

    # Check for lowercase letters
    if re.search(r'[a-z]', password):
        score += 1
    else:
        suggestions.append("Include at least one lowercase letter.")

    # Check for digits
    if re.search(r'\d', password):
        score += 1
    else:
        suggestions.append("Include at least one digit.")

    # Check for special characters
    if re.search(r'[\W_]', password):
        score += 1
    else:
        suggestions.append("Include at least one special character.")

    # Determine strength rating based on the score
    if score <= 2:
        strength = "Weak"
    elif score in [3, 4]:
        strength = "Moderate"
    else:
        strength = "Strong"

    return strength, score, suggestions

def main():
    print("Password Strength Checker")
    # Using getpass to hide input for privacy; replace with input() if needed.
    password = getpass.getpass("Enter a password to evaluate: ")
    
    strength, score, suggestions = evaluate_password_strength(password)
    
    print(f"\nPassword Strength: {strength}")
    print(f"Score: {score} out of 5")
    
    if score == 5:
        print("\nExplanation: This password is strong because it meets all the required criteria: it is at least 8 characters long, includes both uppercase and lowercase letters, contains at least one digit, and has at least one special character.")
    elif suggestions:
        print("\nSuggestions for improvement:")
        for suggestion in suggestions:
            print(f" - {suggestion}")

if __name__ == '__main__':
    main()

#!/usr/bin/env python3
from datetime import datetime
try:
    from dateutil.relativedelta import relativedelta
except ImportError:
    print("This script requires the 'python-dateutil' module. Install it via 'pip3 install python-dateutil'")
    exit(1)

def calculate_age(birth_date, current_date):
    """Calculate the difference between two dates as (years, months, days) using relativedelta."""
    delta = relativedelta(current_date, birth_date)
    return delta.years, delta.months, delta.days

def main():
    print("Select an option:")
    print("1. Calculate an age from a date of birth")
    print("2. Calculate a birth date from an exact age")
    choice = input("Enter 1 or 2: ").strip()
    
    today = datetime.today()
    
    if choice == "1":
        dob_str = input("Enter a date of birth (YYYY-MM-DD): ").strip()
        try:
            birth_date = datetime.strptime(dob_str, "%Y-%m-%d")
        except ValueError:
            print("Invalid date format. Please use YYYY-MM-DD.")
            exit(1)
        
        years, months, days = calculate_age(birth_date, today)
        print(f"Calculated age: {years} years, {months} months, and {days} days.")
    
    elif choice == "2":
        print("Enter an exact age as three numbers separated by spaces.")
        print("For example, if the age is 25 years, 4 months, and 15 days, type: 25 4 15")
        age_input = input("Exact age (years months days): ").strip()
        parts = age_input.split()
        if len(parts) != 3:
            print("Invalid input. Please enter three integers separated by spaces.")
            exit(1)
        try:
            years = int(parts[0])
            months = int(parts[1])
            days = int(parts[2])
        except ValueError:
            print("Invalid input. Please ensure you enter numbers for years, months, and days.")
            exit(1)
        
        birth_date = today - relativedelta(years=years, months=months, days=days)
        print("Calculated birth date is approximately:", birth_date.strftime("%Y-%m-%d"))
    
    else:
        print("Invalid option selected.")

if __name__ == '__main__':
    main()

#!/usr/bin/env python3

def remove_duplicates(input_string):
    # Split the input string by commas and remove any extra spaces
    items = [item.strip() for item in input_string.split(',')]
    unique_items = []
    seen = set()

    for item in items:
        # Convert to lowercase for case-insensitive comparison
        if item.lower() not in seen:
            seen.add(item.lower())
            unique_items.append(item)
    return unique_items

if __name__ == '__main__':
    user_input = input("Enter a comma-separated list of strings: ")
    unique = remove_duplicates(user_input)
    print("Unique entries:", ", ".join(unique))

#!/usr/bin/env python3
import os
import sys
import getpass
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Protocol.KDF import PBKDF2
from Crypto.Util.Padding import pad, unpad

HEADER_MAGIC = b"ENCR"  # 4 bytes header to identify our encrypted files
SALT_SIZE = 16          # Salt size in bytes
IV_SIZE = 16            # AES block size
PBKDF2_ITERATIONS = 100000

def list_files():
    files = [f for f in os.listdir('.') if os.path.isfile(f)]
    if not files:
        print("No files found in the current directory.")
        sys.exit(1)
    print("Files in the current directory:")
    for i, f in enumerate(files, start=1):
        print(f"  {i}. {f}")
    return files

def choose_file(files):
    try:
        choice = int(input("Select a file number: "))
        if choice < 1 or choice > len(files):
            raise ValueError
    except ValueError:
        print("Invalid selection.")
        sys.exit(1)
    return files[choice - 1]

def get_password(confirm=False):
    pwd = getpass.getpass("Enter password: ")
    if confirm:
        pwd_confirm = getpass.getpass("Confirm password: ")
        if pwd != pwd_confirm:
            print("Passwords do not match.")
            sys.exit(1)
    return pwd.encode()  # work with bytes

def encrypt_file(filepath):
    print("\n--- Encryption ---")
    # Choose key size
    key_size_choice = input("Choose key size (enter 128 or 256): ").strip()
    if key_size_choice not in ("128", "256"):
        print("Invalid key size selection.")
        sys.exit(1)
    key_len = 16 if key_size_choice == "128" else 32

    password = get_password(confirm=True)

    # Generate a random salt and IV
    salt = get_random_bytes(SALT_SIZE)
    iv = get_random_bytes(IV_SIZE)

    # Derive the AES key from the password and salt
    key = PBKDF2(password, salt, dkLen=key_len, count=PBKDF2_ITERATIONS)

    # Read file data
    try:
        with open(filepath, "rb") as f:
            data = f.read()
    except IOError as e:
        print(f"Error reading file: {e}")
        sys.exit(1)

    # Pad and encrypt the data using CBC mode
    cipher = AES.new(key, AES.MODE_CBC, iv)
    ciphertext = cipher.encrypt(pad(data, AES.block_size))

    # Create an output file format:
    # [4 bytes header][1 byte key length indicator][16 bytes salt][16 bytes IV][ciphertext]
    # We store key length as one byte: 16 (for 128-bit) or 32 (for 256-bit)
    header = HEADER_MAGIC + bytes([key_len]) + salt + iv
    out_data = header + ciphertext

    # Determine output file name
    out_filepath = filepath + ".enc"
    try:
        with open(out_filepath, "wb") as f:
            f.write(out_data)
    except IOError as e:
        print(f"Error writing encrypted file: {e}")
        sys.exit(1)

    print(f"Encryption successful. Encrypted file: {out_filepath}")

def decrypt_file(filepath):
    print("\n--- Decryption ---")
    # Read the encrypted file and parse header information
    try:
        with open(filepath, "rb") as f:
            file_data = f.read()
    except IOError as e:
        print(f"Error reading file: {e}")
        sys.exit(1)

    # Verify header length
    header_length = len(HEADER_MAGIC) + 1 + SALT_SIZE + IV_SIZE
    if len(file_data) < header_length:
        print("File is too short to be a valid encrypted file.")
        sys.exit(1)

    header = file_data[:len(HEADER_MAGIC)]
    if header != HEADER_MAGIC:
        print("Invalid file format (missing header).")
        sys.exit(1)

    key_len = file_data[len(HEADER_MAGIC)]
    if key_len not in (16, 32):
        print("Invalid key length in file header.")
        sys.exit(1)

    salt = file_data[len(HEADER_MAGIC)+1 : len(HEADER_MAGIC)+1+SALT_SIZE]
    iv_start = len(HEADER_MAGIC)+1+SALT_SIZE
    iv = file_data[iv_start : iv_start+IV_SIZE]
    ciphertext = file_data[iv_start+IV_SIZE:]

    password = get_password(confirm=False)
    key = PBKDF2(password, salt, dkLen=key_len, count=PBKDF2_ITERATIONS)

    # Decrypt and unpad the data
    cipher = AES.new(key, AES.MODE_CBC, iv)
    try:
        plaintext_padded = cipher.decrypt(ciphertext)
        plaintext = unpad(plaintext_padded, AES.block_size)
    except (ValueError, KeyError):
        print("Decryption failed. Incorrect password or corrupted file.")
        sys.exit(1)

    # Determine output file name
    if filepath.endswith(".enc"):
        out_filepath = filepath[:-4]  # remove the .enc extension
    else:
        out_filepath = filepath + ".dec"

    try:
        with open(out_filepath, "wb") as f:
            f.write(plaintext)
    except IOError as e:
        print(f"Error writing decrypted file: {e}")
        sys.exit(1)

    print(f"Decryption successful. Decrypted file: {out_filepath}")

def main():
    print("AES Encryption/Decryption Utility")
    mode = input("Do you want to (E)ncrypt or (D)ecrypt? ").strip().lower()
    if mode not in ("e", "d"):
        print("Invalid mode selection.")
        sys.exit(1)

    files = list_files()
    selected_file = choose_file(files)

    if mode == "e":
        encrypt_file(selected_file)
    else:
        decrypt_file(selected_file)

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import qrcode

def generate_qr_code(data, filename="qr_code.png"):
    """
    Generates a QR code from the provided data and saves it to a file.

    Parameters:
        data (str): The text or URL to encode.
        filename (str): The name of the file to save the QR code image.
    
    Returns:
        str: The filename where the QR code is saved.
    """
    # Create a QRCode object with desired settings.
    qr = qrcode.QRCode(
        version=1,  # 1 means 21x21 matrix; increase for more data.
        error_correction=qrcode.constants.ERROR_CORRECT_H,  # High error correction.
        box_size=10,  # Size of each box in pixels.
        border=4,  # Border size in boxes.
    )
    
    # Add data to the QR code.
    qr.add_data(data)
    qr.make(fit=True)
    
    # Create an image from the QR code instance.
    img = qr.make_image(fill_color="black", back_color="white")
    img.save(filename)
    return filename

def main():
    print("=== QR Code Generator ===\n")
    data = input("Enter the text or URL you want to encode in the QR code: ").strip()
    if not data:
        print("No data provided. Exiting.")
        return

    filename = generate_qr_code(data)
    print(f"\nQR code generated and saved as '{filename}'.")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import requests

def shorten_url(url):
    """
    Shortens the given URL using the TinyURL API.
    
    Parameters:
        url (str): The original URL.
    
    Returns:
        str: The shortened URL or None if something went wrong.
    """
    api_url = 'https://tinyurl.com/api-create.php'
    params = {'url': url}
    try:
        response = requests.get(api_url, params=params)
        if response.status_code == 200:
            return response.text.strip()
        else:
            print(f"Error: Unable to shorten URL. Status code: {response.status_code}")
            return None
    except Exception as e:
        print("Error during request:", e)
        return None

def main():
    print("=== Welcome to the Python URL Shortener ===\n")
    
    # Get URL from user
    original_url = input("Enter the URL you want to shorten: ").strip()
    if not original_url:
        print("No URL provided. Exiting.")
        return

    # Get the shortened URL
    shortened_url = shorten_url(original_url)
    if shortened_url:
        # Display the original and shortened URLs
        print("\nHere are your URLs:")
        print("-" * 40)
        print("Original URL:  ", original_url)
        print("Shortened URL: ", shortened_url)
        print("-" * 40)
    else:
        print("Failed to shorten the URL.")

if __name__ == "__main__":
    main()