Merge branch 'master' into eggshell

Author: avinashkranjan

.github/workflows/auto-assign.yml

@@ -3,8 +3,6 @@ name: Auto Assign
 on:
   issue_comment:
     types: [created]
-  schedule:
-    - cron: '0 0 * * *' # Runs daily at midnight
   workflow_dispatch:
 
 jobs:
@@ -39,4 +37,4 @@ jobs:
               return github.issues.addAssignees(config);
             } else {
               return true;
-            }
+            }

Automation script/automation.py

@@ -0,0 +1,64 @@
+import os
+import requests
+from PIL import Image
+#Import necessary libraries
+
+website_url = "https://example.com/images/"
+#Define the URL of the website containing the images you want to download
+
+def download_images(url, download_folder):
+    response = requests.get(url)
+    image_names = ["image1.jpg", "image2.jpg", "image3.jpg"]  # Replace with actual image names or fetch them dynamically
+    for name in image_names:
+        image_url = url + name
+        image_path = os.path.join(download_folder, name)
+        with open(image_path, 'wb') as f:
+            f.write(response.content)
+#Create a function to download images from the website
+
+def resize_images(input_folder, output_folder, target_size):
+    for filename in os.listdir(input_folder):
+        input_path = os.path.join(input_folder, filename)
+        output_path = os.path.join(output_folder, filename)
+        img = Image.open(input_path)
+        img_resized = img.resize(target_size)
+        img_resized.save(output_path)
+
+#Create a function to resize images
+def resize_images(input_folder, output_folder, target_size):
+    for filename in os.listdir(input_folder):
+        input_path = os.path.join(input_folder, filename)
+        output_path = os.path.join(output_folder, filename)
+        img = Image.open(input_path)
+        img_resized = img.resize(target_size)
+        img_resized.save(output_path)
+
+
+#Define the target size for the resized images
+target_size = (300, 200)  # Width x Height in pixels
+
+def organize_images_by_dimensions(input_folder):
+    for filename in os.listdir(input_folder):
+        input_path = os.path.join(input_folder, filename)
+        img = Image.open(input_path)
+        width, height = img.size
+        folder_name = f"{width}x{height}"
+        folder_path = os.path.join(input_folder, folder_name)
+        if not os.path.exists(folder_path):
+            os.mkdir(folder_path)
+        output_path = os.path.join(folder_path, filename)
+        shutil.move(input_path, output_path
+#Create a function to organize images into folders based on their dimensions      
+
+#Main function to execute the automation script
+if __name__ == "__main__":
+    download_folder = "downloads"
+    os.makedirs(download_folder, exist_ok=True)
+    download_images(website_url, download_folder)
+
+    resize_folder = "resized"
+    os.makedirs(resize_folder, exist_ok=True)
+    resize_images(download_folder, resize_folder, target_size)
+
+    organize_images_by_dimensions(resize_folder)
+

Ciphey tool/README.md

@@ -0,0 +1,18 @@
+# Ciphey - Automated Decryption Tool
+
+Ciphey is an automated decryption tool that uses smart artificial intelligence and natural language processing to automatically decrypt encrypted text. Simply input encrypted text, and Ciphey will attempt to find the decrypted text for you.
+
+## Installation
+
+To use Ciphey, you need Python 3.7 or higher. It is recommended to use a virtual environment to isolate the tool's dependencies.
+
+1. Clone the Ciphey repository
+2. Change into the Ciphey directory
+3. Install the required dependencies using `pip`:
+```pip install -r requirements.txt
+```
+## Usage
+
+You can run Ciphey with the following command:
+```python ciphey.py ```
+

Ciphey tool/ciphey.py

@@ -0,0 +1,158 @@
+import os
+import warnings
+from typing import Any, Optional, Union
+
+import click
+from appdirs import AppDirs
+import logging
+from rich.logging import RichHandler
+from rich.console import Console
+
+from ciphey import iface
+
+warnings.filterwarnings("ignore")
+
+console = Console()
+
+
+def decrypt(config: iface.Config, ctext: Any) -> Union[str, bytes]:
+    """A simple alias for searching a ctext and makes the answer pretty"""
+    res: Optional[iface.SearchResult] = config.objs["searcher"].search(ctext)
+    if res is None:
+        return "Failed to crack"
+    if config.verbosity < 0:
+        return res.path[-1].result.value
+    else:
+        return iface.pretty_search_results(res)
+
+
+def print_help(ctx):
+    # prints help menu
+    # if no arguments are passed
+    click.echo(ctx.get_help())
+    ctx.exit()
+
+
+@click.command()
+@click.option(
+    "-t",
+    "--text",
+    help="The ciphertext you want to decrypt.",
+    type=str,
+)
+@click.option(
+    "-q", "--quiet", help="Decrease verbosity", type=int, count=True, default=None
+)
+@click.option(
+    "-g",
+    "--greppable",
+    help="Only print the answer (useful for grep)",
+    is_flag=True,
+    default=None,
+)
+@click.option("-v", "--verbose", count=True, type=int)
+@click.option("-C", "--checker", help="Use the given checker", default=None)
+@click.option(
+    "-c",
+    "--config",
+    help="Uses the given config file. Defaults to appdirs.user_config_dir('ciphey', 'ciphey')/'config.yml'",
+)
+@click.option("-w", "--wordlist", help="Uses the given wordlist")
+@click.option(
+    "-p",
+    "--param",
+    help="Passes a parameter to the language checker",
+    multiple=True,
+)
+@click.option(
+    "-l",
+    "--list-params",
+    help="List the parameters of the selected module",
+    is_flag=True,
+)
+@click.option(
+    "--searcher",
+    help="Select the searching algorithm to use",
+)
+@click.option(
+    "-b",
+    "--bytes",
+    help="Forces Ciphey to use binary mode for the input",
+    is_flag=True,
+    default=None,
+)
+@click.option(
+    "--default-dist",
+    help="Sets the default character/byte distribution",
+    type=str,
+    default=None,
+)
+@click.option(
+    "-m",
+    "--module",
+    help="Adds a module from the given path",
+    type=click.Path(),
+    multiple=True,
+)
+@click.option(
+    "-A",
+    "--appdirs",
+    help="Print the location of where Ciphey wants the settings file to be",
+    is_flag=True,
+)
+@click.option("-f", "--file", type=click.File("rb"), required=False)
+@click.argument("text_stdin", callback=iface.get_input_from_stdin, required=False)
+def main(**kwargs):
+# Initialize the console and logging
+    console = Console()
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(message)s",
+        datefmt="[%X]",
+        handlers=[RichHandler(console=console, rich_tracebacks=True)],
+    )
+
+    # Create the configuration object
+    config = iface.Config()
+
+    # Load the settings file into the config
+    config.load_settings_file(kwargs["config"])
+
+    # Set verbosity level
+    verbosity = kwargs["verbose"] - kwargs["quiet"] if kwargs["verbose"] is not None else None
+    config.set_verbosity(verbosity)
+
+    # Load additional options into the config
+    config.set_option("checker", kwargs["checker"])
+    config.set_option("searcher", kwargs["searcher"])
+    config.set_option("default_dist", kwargs["default_dist"])
+    config.set_option("wordlist", kwargs["wordlist"])
+
+    # Load additional modules
+    config.load_modules(kwargs["module"])
+
+    # Update parameters
+    config.update_parameters(kwargs["param"])
+
+    # Complete the configuration setup
+    config.complete_config()
+
+    # Process the input text
+    input_text = kwargs["text"] or kwargs["text_stdin"]
+    if isinstance(input_text, bytes) and not kwargs["bytes"]:
+        input_text = input_text.decode("utf-8")
+    elif isinstance(input_text, str) and kwargs["bytes"]:
+        input_text = input_text.encode("utf-8")
+
+    # Perform decryption
+    result = None
+    with console.status("[bold green]Thinking...", spinner="moon") as status:
+        config.set_spinner(status)
+        result = decrypt(config, input_text)
+
+    # Print the result
+    console.print(result)
+
+
+if __name__ == "__main__":
+    main()

Ciphey tool/dependencies.md

@@ -0,0 +1,13 @@
+# Dependencies
+
+The Ciphey tool relies on several modules and dependencies. Here are the main ones:
+
+- Ciphey Core: The core functionality of the Ciphey tool. It can be installed using pip install ciphey.
+
+- Click: A command-line interface (CLI) library for Python. It handles the command-line options and arguments. Install it with pip install click.
+
+- AppDirs: A Python module for determining appropriate application directories on various operating systems. It is used to handle the location of the configuration file. Install it with pip install appdirs.
+
+- Rich: A library for rich text and beautiful formatting in the terminal. It is used for enhanced logging output and spinner display. Install it with pip install rich.
+
+Make sure to install these dependencies before running the enhanced Ciphey tool. You can install them by running the corresponding pip install commands mentioned above.

Ciphey tool/requirements.txt

@@ -0,0 +1,4 @@
+appdirs
+click
+rich
+ciphey

CrossLinked/Readme.md

@@ -0,0 +1,4 @@
+# CrossLinked
+
+CrossLinked is a LinkedIn enumeration tool that uses search engine scraping to collect valid employee names from an organization. This technique provides accurate results without the use of API keys, credentials, or accessing LinkedIn directly!
+

CrossLinked/logger.py

@@ -0,0 +1,89 @@
+import os
+import sys
+import logging
+
+STYLE = {'None': '0',
+         'bold': '1'
+         }
+
+FG = {'None': '',
+      'gray': ';30',
+      'red': ';31',
+      'green': ';32',
+      'yellow': ';33',
+      'blue': ';34',
+      'purple': ';35',
+      'cyan': ';36'
+      }
+
+
+class Log:
+    # Quick log class for CLI output
+    @staticmethod
+    def info(msg):
+        print(' '.join([highlight('[*]', 'bold', 'blue'), msg]))
+
+    @staticmethod
+    def success(msg):
+        print(' '.join([highlight('[+]', 'bold', 'green'), msg]))
+
+    @staticmethod
+    def warn(msg):
+        print(' '.join([highlight('[*]', 'bold', 'yellow'), msg]))
+
+
+def code_gen(data, style, color, windows=False):
+    return data if windows else '\033[0{}{}m{}\033[0m'.format(STYLE[style], FG[color], data)
+
+
+def highlight(data, style='bold', fg='blue'):
+    return code_gen(data, style, fg, windows=True if os.name == 'nt' else False)
+
+
+def debug_args(args):
+    for k in args.__dict__:
+        logging.debug('{:20} => {}'.format(k, args.__dict__[k]))
+
+
+def setup_debug_logger():
+    debug_output_string = "{} %(message)s".format(highlight('DEBUG', fg='purple'))
+    formatter = logging.Formatter(debug_output_string)
+    streamHandler = logging.StreamHandler(sys.stdout)
+    streamHandler.setFormatter(formatter)
+
+    root_logger = logging.getLogger()
+    root_logger.propagate = False
+    root_logger.addHandler(streamHandler)
+    root_logger.setLevel(logging.DEBUG)
+    return root_logger
+
+
+def setup_file_logger(file_name, log_name='cLinked_file', file_mode='w'):
+    formatter = logging.Formatter('%(message)s')
+    fileHandler = logging.FileHandler(file_name, file_mode)
+    fileHandler.setFormatter(formatter)
+
+    logger = logging.getLogger(log_name)
+    logger.propagate = False
+    logger.addHandler(fileHandler)
+    logger.setLevel(logging.INFO)
+
+    first_run(logger) if not os.path.exists(file_name) else False
+    return logger
+
+
+def first_run(logger):
+    # init headings in CSV log file
+    logger.info('Datetime, Search, Name, Title, URL, rawText')
+
+
+def setup_cli_logger(log_level=logging.INFO, logger_name='cLinked'):
+    formatter = logging.Formatter('%(message)s')
+    StreamHandler = logging.StreamHandler(sys.stdout)
+    StreamHandler.setFormatter(formatter)
+
+    logger = logging.getLogger(logger_name)
+    logger.propagate = False
+    logger.addHandler(StreamHandler)
+    logger.setLevel(log_level)
+    return logger