akii 0.1.0__tar.gz

akii-0.1.0/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: akii
+Version: 0.1.0
+Summary: HTTP header analyzer
+License-Expression: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.32.0
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: colorama>=0.4.6
+
+# AkII
+
+> A fast and lightweight HTTP security header analyzer.
+
+AkII is an open-source security tool for analyzing HTTP response headers and identifying common security misconfigurations, such as weak or missing security headers.
+
+> **⚠️ Early Development**
+>
+> AkII is in an early stage of development. Some features are still incomplete, and bugs are expected. The project is under active development, and new functionality will be added in future releases.
+
+## Features
+
+- Analyze HTTP security headers
+- Detect common CORS misconfigurations
+- Detect missing or insecure Content Security Policy (CSP)
+- Human-readable terminal output
+- JSON output for automation
+- Lightweight and extensible YAML-based rule engine
+
+## Why AkII?
+
+AkII is designed for speed, automation, and extensibility.
+
+AkII focuses on one task: analyzing HTTP security headers quickly and consistently.
+
+It is suitable for:
+
+- CI/CD pipelines
+- Security automation
+- Bug bounty workflows
+- Batch scanning with wordlists
+- Integration into custom tools
+
+## Installation
+
+### From PyPI (Recommended)
+
+```bash
+pipx install akii
+```
+
+or
+
+```bash
+pip install akii
+```
+
+### From Source
+
+```bash
+git clone https://github.com/MintTester-IO/AkII.git
+cd akii
+pip install -e .
+```
+
+## Uninstallation
+
+If you installed AkII with **pipx**:
+
+```bash
+pipx uninstall akii
+```
+
+If you installed AkII with **pip**:
+
+```bash
+pip uninstall akii
+```
+
+If you installed AkII from source using `pip install -e .`:
+
+```bash
+pip uninstall akii
+cd ..
+rm -rf akii
+```
+
+## Usage
+
+Scan a single target:
+
+```bash
+akii -T https://example.com
+```
+
+Scan multiple targets:
+
+```bash
+akii -w targets.txt
+```
+
+Show request headers:
+
+```bash
+akii -T https://example.com --request
+```
+
+Show response headers:
+
+```bash
+akii -T https://example.com --response
+```
+
+Verbose mode:
+
+```bash
+akii -T https://example.com --verbose
+```
+
+Save the report:
+
+```bash
+akii -T https://example.com -o report.txt
+```
+
+Export JSON:
+
+```bash
+akii -T https://example.com -jo report.txt
+```
+
+## Current Checks
+
+- Cross-Origin Resource Sharing (CORS)
+- Content Security Policy (CSP)
+
+More security header checks will be added in future releases.
+
+## Project Structure
+
+```
+src/akii/
+├── checks/      # Detection and analysis modules
+├── core/        # Controller, CLI, reporting
+├── http/        # HTTP client
+├── templates/   # YAML rule definitions
+└── ui/          # Terminal output
+```
+
+## Roadmap
+
+- HSTS analysis
+- Cookie analysis
+- Cache-Control analysis
+- Permissions-Policy analysis
+- Referrer-Policy analysis
+- HTML reports
+- Improved JSON reporting
+- Plugin system
+
+## Contributing
+
+Contributions are welcome.
+
+If you find a bug, have a feature request, or would like to improve AkII, please open an issue or submit a pull request.
+
+## License
+
+This project is licensed under the MIT License.

akii-0.1.0/README.md

@@ -0,0 +1,159 @@
+# AkII
+
+> A fast and lightweight HTTP security header analyzer.
+
+AkII is an open-source security tool for analyzing HTTP response headers and identifying common security misconfigurations, such as weak or missing security headers.
+
+> **⚠️ Early Development**
+>
+> AkII is in an early stage of development. Some features are still incomplete, and bugs are expected. The project is under active development, and new functionality will be added in future releases.
+
+## Features
+
+- Analyze HTTP security headers
+- Detect common CORS misconfigurations
+- Detect missing or insecure Content Security Policy (CSP)
+- Human-readable terminal output
+- JSON output for automation
+- Lightweight and extensible YAML-based rule engine
+
+## Why AkII?
+
+AkII is designed for speed, automation, and extensibility.
+
+AkII focuses on one task: analyzing HTTP security headers quickly and consistently.
+
+It is suitable for:
+
+- CI/CD pipelines
+- Security automation
+- Bug bounty workflows
+- Batch scanning with wordlists
+- Integration into custom tools
+
+## Installation
+
+### From PyPI (Recommended)
+
+```bash
+pipx install akii
+```
+
+or
+
+```bash
+pip install akii
+```
+
+### From Source
+
+```bash
+git clone https://github.com/MintTester-IO/AkII.git
+cd akii
+pip install -e .
+```
+
+## Uninstallation
+
+If you installed AkII with **pipx**:
+
+```bash
+pipx uninstall akii
+```
+
+If you installed AkII with **pip**:
+
+```bash
+pip uninstall akii
+```
+
+If you installed AkII from source using `pip install -e .`:
+
+```bash
+pip uninstall akii
+cd ..
+rm -rf akii
+```
+
+## Usage
+
+Scan a single target:
+
+```bash
+akii -T https://example.com
+```
+
+Scan multiple targets:
+
+```bash
+akii -w targets.txt
+```
+
+Show request headers:
+
+```bash
+akii -T https://example.com --request
+```
+
+Show response headers:
+
+```bash
+akii -T https://example.com --response
+```
+
+Verbose mode:
+
+```bash
+akii -T https://example.com --verbose
+```
+
+Save the report:
+
+```bash
+akii -T https://example.com -o report.txt
+```
+
+Export JSON:
+
+```bash
+akii -T https://example.com -jo report.txt
+```
+
+## Current Checks
+
+- Cross-Origin Resource Sharing (CORS)
+- Content Security Policy (CSP)
+
+More security header checks will be added in future releases.
+
+## Project Structure
+
+```
+src/akii/
+├── checks/      # Detection and analysis modules
+├── core/        # Controller, CLI, reporting
+├── http/        # HTTP client
+├── templates/   # YAML rule definitions
+└── ui/          # Terminal output
+```
+
+## Roadmap
+
+- HSTS analysis
+- Cookie analysis
+- Cache-Control analysis
+- Permissions-Policy analysis
+- Referrer-Policy analysis
+- HTML reports
+- Improved JSON reporting
+- Plugin system
+
+## Contributing
+
+Contributions are welcome.
+
+If you find a bug, have a feature request, or would like to improve AkII, please open an issue or submit a pull request.
+
+## License
+
+This project is licensed under the MIT License.

akii-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "akii"
+version = "0.1.0"
+description = "HTTP header analyzer"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+
+dependencies = [
+    "requests>=2.32.0",
+    "PyYAML>=6.0",
+    "colorama>=0.4.6",
+]
+
+[project.scripts]
+akii = "akii.core.cli.main:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

akii-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

akii-0.1.0/src/akii/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

akii-0.1.0/src/akii/checks/__init__.py

@@ -0,0 +1,7 @@
+from .cors import cors_runner
+from .csp import csp_runner
+
+CHECKERS = [
+    cors_runner,
+    csp_runner,
+]

akii-0.1.0/src/akii/checks/cors.py

@@ -0,0 +1,43 @@
+from akii.core.template_loader import load_template
+
+RULE = load_template("cors")
+
+
+def cors_detect(config, response):
+    findings = {}
+
+    for check in RULE["checks"]:
+        header = check["header"]
+
+        if header in response.headers:
+            findings[header] = response.headers[header]
+
+    return findings
+
+
+def cors_analyze(findings):
+    results = []
+
+    for check in RULE["checks"]:
+        header = check["header"]
+
+        if header not in findings:
+            continue
+
+        value = findings[header]
+
+        for rule in check.get("rules", []):
+            if value == rule["value"]:
+                results.append({
+                    "header": header,
+                    "value": value,
+                    "severity": rule["severity"],
+                    "message": rule["message"],
+                })
+
+    return results
+
+
+def cors_runner(config, response):
+    findings = cors_detect(config, response)
+    return cors_analyze(findings)

akii-0.1.0/src/akii/checks/csp.py

@@ -0,0 +1,49 @@
+from akii.core.template_loader import load_template
+
+RULE = load_template("csp")
+
+
+def csp_detect(config, response):
+    findings = {}
+
+    for check in RULE["checks"]:
+        header = check["header"]
+
+        if header in response.headers:
+            findings[header] = response.headers[header]
+
+    return findings
+
+
+def csp_analyze(findings):
+    results = []
+
+    for check in RULE["checks"]:
+        header = check["header"]
+
+        if header not in findings:
+            if check.get("required", False):
+                results.append({
+                    "header": header,
+                    "severity": "info",
+                    "message": f"Missing required header: {header}",
+                })
+            continue
+
+        value = findings[header]
+
+        for rule in check.get("rules", []):
+            if rule["value"] in value:
+                results.append({
+                    "header": header,
+                    "value": rule["value"],
+                    "severity": rule["severity"],
+                    "message": rule["message"],
+                })
+
+    return results
+
+
+def csp_runner(config, response):
+    findings = csp_detect(config, response)
+    return csp_analyze(findings)

akii-0.1.0/src/akii/core/cli/main.py

@@ -0,0 +1,13 @@
+from akii.core.cli.parser import build_parser
+from akii.core.controller import run
+from akii.ui.output import banner
+
+def main():
+    banner()
+    parser = build_parser()
+    args = parser.parse_args()
+    config = vars(args)
+    run(config)
+
+if __name__ == "__main__":
+    main()

akii-0.1.0/src/akii/core/cli/parser.py

@@ -0,0 +1,66 @@
+import argparse
+
+from akii.core.flags.general import (
+    INPUT_FLAGS,
+    REQUEST_FLAGS,
+    PERFORMANCE_FLAGS,
+    OUTPUT_FLAGS,
+    MISCELLANEOUS_FLAGS,
+)
+
+
+FLAG_GROUPS = (
+    ("Input", INPUT_FLAGS),
+    ("Request", REQUEST_FLAGS),
+    ("Performance", PERFORMANCE_FLAGS),
+    ("Output", OUTPUT_FLAGS),
+    ("Miscellaneous", MISCELLANEOUS_FLAGS),
+)
+
+
+def build_parser():
+    """Create and configure the CLI argument parser."""
+
+    parser = argparse.ArgumentParser(
+        prog="akii",
+        description="HTTP header analyzer",
+        formatter_class=lambda prog: argparse.HelpFormatter(
+            prog,
+            max_help_position=50,
+            width=130,
+        ),
+    )
+
+    # Create and register all argument groups.
+    for title, flags in FLAG_GROUPS:
+        group = parser.add_argument_group(title)
+        register_flags(group, flags)
+
+    return parser
+
+
+def register_flags(group, flags):
+    """Register a collection of CLI flags to an argument group."""
+
+    for value in flags.values():
+        kwargs = {
+            "help": value["help"],
+        }
+
+        # Copy optional keyword arguments if present.
+        for key in (
+            "action",
+            "type",
+            "default",
+            "choices",
+            "nargs",
+            "metavar",
+            "required",
+        ):
+            if key in value:
+                kwargs[key] = value[key]
+
+        group.add_argument(
+            *value["flags"],
+            **kwargs,
+        )

akii-0.1.0/src/akii/core/controller.py

@@ -0,0 +1,70 @@
+import re
+
+from akii.http.client import request
+from akii.ui.output import display_http, csp_result, cors_result, display_target
+from akii.checks.csp import csp_runner
+from akii.checks.cors import cors_runner
+from akii.core.reporter import txt_output, json_output
+
+
+URL_RE = re.compile(r"https?://[^\s]+")
+
+
+def extract_url(line):
+    match = URL_RE.search(line)
+    return match.group(0) if match else None
+
+
+def load_input(config):
+    if not config.get("wordlist"):
+        return [config]
+
+    configs = []
+
+    with open(config["wordlist"], encoding="utf-8") as f:
+        for line in f:
+            url = extract_url(line)
+
+            if not url:
+                continue
+
+            target_config = config.copy()
+            target_config["target"] = url
+            configs.append(target_config)
+
+    return configs
+
+
+def process_target(config):
+    display_target(config)
+
+    response = request(config)
+
+    display_http(config, response)
+
+    cors_results = cors_runner(config, response)
+    cors_result(cors_results)
+
+    csp_results = csp_runner(config, response)
+    csp_result(csp_results)
+
+    return {
+        "target": config["target"],
+        "cors": cors_results,
+        "csp": csp_results,
+    }
+
+
+def run(config):
+    inputs = load_input(config)
+
+    all_results = []
+
+    for target_config in inputs:
+        all_results.append(process_target(target_config))
+
+    if config.get("output"):
+        if config.get("json"):
+            json_output(all_results, config["output"])
+        else:
+            txt_output(all_results, config["output"])

akii-0.1.0/src/akii/core/flags/general.py

@@ -0,0 +1,109 @@
+INPUT_FLAGS = {
+    "Target": {
+        "flags": ["-T", "--target"],
+        "type": str,
+        "default": None,
+        "help": "Target URL or host to analyze.",
+        "metavar": "",
+    },
+
+    "Wordlist": {
+        "flags": ["-w", "--wordlist"],
+        "type": str,
+        "default": None,
+        "help": "Read targets from a wordlist file.",
+        "metavar": "",
+    }
+}
+
+REQUEST_FLAGS = {
+    "Method": {
+        "flags": ["-X", "--method"],
+        "type": str,
+        "default": "GET",
+        "help": "HTTP request method (default: GET).",
+        "metavar": "",
+    },
+
+    "Header": {
+        "flags": ["-H", "--header"],
+        "type": str,
+        "default": None,
+        "help": "Add a custom HTTP header (e.g. 'Authorization: Bearer <token>').",
+        "metavar": "",
+    },
+
+    "Cookie": {
+        "flags": ["-C", "--cookie"],
+        "type": str,
+        "default": None,
+        "help": "Send cookies with the request (e.g. 'session=abc123').",
+        "metavar": "",
+    },
+
+    "Data": {
+        "flags": ["-D", "--data"],
+        "type": str,
+        "default": None,
+        "help": "Send data in the request body.",
+        "metavar": "",
+    },
+}
+
+PERFORMANCE_FLAGS = {
+    "Concurrency": {
+        "flags": ["-c", "--concurrency"],
+        "type": int,
+        "default": 1,
+        "help": "Number of concurrent requests.",
+        "metavar": "",
+    },
+}
+
+OUTPUT_FLAGS = {
+    "Output": {
+        "flags": ["-o", "--output"],
+        "type": str,
+        "default": None,
+        "help": "Write results to the specified file.",
+        "metavar": "",
+    },
+
+    "JSON": {
+        "flags": ["-j", "--json"],
+        "action": "store_true",
+        "help": "Output results in JSON format.",
+    },
+
+    "Request_Header": {
+        "flags": ["--request"],
+        "action": "store_true",
+        "help": "Display the HTTP request headers.",
+    },
+
+    "Response_Header": {
+        "flags": ["--response"],
+        "action": "store_true",
+        "help": "Display the HTTP response headers.",
+    },
+
+    "Verbose": {
+        "flags": ["--verbose"],
+        "action": "store_true",
+        "help": "Display both the HTTP request and response.",
+    },
+}
+
+MISCELLANEOUS_FLAGS = {
+    "Version": {
+        "flags": ["-v", "--version"],
+        "action": "store_true",
+        "help": "Show version information.",
+    },
+
+    "Update": {
+        "flags": ["--update"],
+        "action": "store_true",
+        "help": "Update Akii to the latest version.",
+    },
+}

akii-0.1.0/src/akii/core/reporter.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+import json
+
+def txt_output(results, output):
+    output_path = Path(output).resolve(strict=False)
+
+    with output_path.open("w", encoding="utf-8") as f:
+        for target in results:
+            f.write("=" * 60)
+            f.write(f"\nTarget: {target['target']}\n\n")
+
+            # CORS
+            f.write("=== CORS Analysis ===\n")
+
+            if not target["cors"]:
+                f.write("No CORS issues found.\n\n")
+            else:
+                for count, result in enumerate(target["cors"], start=1):
+                    f.write(f"({count}> [{result['severity'].upper()}] {result['header']}\n")
+
+                    if "value" in result:
+                        f.write(f"    Value   : {result['value']}\n")
+
+                    f.write(f"    Message : {result['message']}\n")
+
+                f.write("\n")
+
+            # CSP
+            f.write("=== CSP Analysis ===\n")
+
+            if not target["csp"]:
+                f.write("No CSP issues found.\n\n")
+            else:
+                for count, result in enumerate(target["csp"], start=1):
+                    f.write(f"({count}> [{result['severity'].upper()}] {result['header']}\n")
+
+                    if "value" in result:
+                        f.write(f"    Value   : {result['value']}\n")
+
+                    f.write(f"    Message : {result['message']}\n")
+
+                f.write("\n")
+
+def json_output(results, output):
+    output_path = Path(output).resolve(strict=False)
+
+    with output_path.open("w", encoding="utf-8") as f:
+        json.dump(results, f, indent=4, ensure_ascii=False)

akii-0.1.0/src/akii/core/template_loader.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+import yaml
+
+TEMPLATE_DIR = Path(__file__).parent.parent / "templates"
+
+def load_template(name: str) -> dict:
+    template_path = TEMPLATE_DIR / f"{name}.yaml"
+
+    with template_path.open("r", encoding="utf-8") as f:
+        return yaml.safe_load(f)

akii-0.1.0/src/akii/http/client.py

@@ -0,0 +1,28 @@
+import requests
+
+from akii import __version__
+
+def request(config):
+    headers = {
+    "User-Agent": f"AkII/{__version__}",
+    }
+
+    cookies = {}
+
+    if config.get("header"):
+        name, value = config["header"].split(":", 1)
+        headers[name.strip()] = value.strip()
+
+    if config.get("cookie"):
+        name, value = config["cookie"].split("=", 1)
+        cookies[name.strip()] = value.strip()
+
+    r = requests.request(
+        method=config["method"],
+        url=config["target"],
+        headers=headers or None,
+        cookies=cookies or None,
+        data=config.get("data"),
+    )
+
+    return r

akii-0.1.0/src/akii/ui/banner.py

@@ -0,0 +1,38 @@
+def get_banner():
+	# Archived logo
+	headerx = r"""
+:::     ::: ::::::::::  ::::::     :::::::::  :::::::::: :::::::::  :::   ::: 
+:+:     :+: :+:        :+:   :+:   :+:    :+: :+:        :+:    :+: :+:   :+: 
++:+     +:+ +:+       +:+     +:+  +:+    +:+ +:+        +:+    +:+  +:+ +:+  
++#++:++#+#+ +#++:++#  +#++:++#++:  +#+    +:+ +#++:++#   +#++:++#:    +#++:   
++#+     +#+ +#+       +#+     +#+  +#+    +#+ +#+        +#+    +#+  +#+ +#+ 
+#+#     #+# #+#       #+#     #+#  #+#    #+# #+#        #+#    #+# #+#   #+# 
+###     ### ######### ###     ###  #########  ########## ###    ### ###   ###
+"""
+	
+	hdrx = r"""
+
+:::     ::: :::::::::  :::::::::  :::   :::
+:+:     :+: :+:    :+: :+:    :+: :+:   :+:
++:+     +:+ +:+    +:+ +:+    +:+  +:+ +:+ 
++#++:++#+#+ +#+    +:+ +#++:++#:    +#++:  
++#+     +#+ +#+    +#+ +#+    +#+  +#+ +#+ 
+#+#     #+# #+#    #+# #+#    #+# #+#   #+# 
+###     ### #########  ###    ### ###   ###
+"""
+	# Current logo
+	akii = r"""
+   _____     ___   ___  ___  ___
+  :::::::╗   :::║  :::║ :::║ :::║
+ :+:╔══:+:╗  :+:║  :+:║ :+:║ :+:║
++:+╔╝   +:+╗ +:+║  +:+║ ═══╝ ═══╝  
++++║____+++║ +++║__+++║ ___  ___
++#++:++#++:║ +#++:+╣__  +#+║ +#+║
++#+╔════+#+║ +#+╔══+#+║ +#+║ +#+║
+#+#║    #+#║ #+#║  #+#║ #+#║ #+#║ v0.1.0
+###║    ###║ ###║  ###║ ###║ ###║
+═══╝    ═══╝ ═══╝  ═══╝ ═══╝ ═══╝ 
+        - MintTester-IO -
+"""
+	
+	return akii

akii-0.1.0/src/akii/ui/output.py

@@ -0,0 +1,107 @@
+from colorama import Fore, Style, init
+
+from akii.ui.banner import get_banner
+
+init(autoreset=True)
+
+
+def severity_color(severity):
+    severity = severity.upper()
+
+    if severity == "CRITICAL":
+        return Fore.LIGHTRED_EX
+    if severity == "HIGH":
+        return Fore.RED
+    if severity == "MEDIUM":
+        return Fore.YELLOW
+    if severity == "LOW":
+        return Fore.GREEN
+    if severity == "INFO":
+        return Fore.BLUE
+
+    return Fore.WHITE
+
+
+def banner():
+    print(get_banner())
+
+
+def display_http(config, response):
+    if config.get("verbose"):
+        print(Fore.CYAN + "=== Request ===")
+        print(f"{response.request.method} {response.request.url}\n")
+
+        for key, value in response.request.headers.items():
+            print(f"{Fore.GREEN}{key}{Style.RESET_ALL}: {value}")
+
+        print(Fore.CYAN + "\n=== Response ===")
+        print(f"Status: {response.status_code}\n")
+
+        for key, value in response.headers.items():
+            print(f"{Fore.GREEN}{key}{Style.RESET_ALL}: {value}")
+
+        print()
+        return
+
+    if config.get("request"):
+        print(Fore.CYAN + "=== Request ===")
+        print(f"{response.request.method} {response.request.url}\n")
+
+        for key, value in response.request.headers.items():
+            print(f"{Fore.GREEN}{key}{Style.RESET_ALL}: {value}")
+
+        print()
+
+    if config.get("response"):
+        print(Fore.CYAN + "=== Response ===")
+        print(f"Status: {response.status_code}\n")
+
+        for key, value in response.headers.items():
+            print(f"{Fore.GREEN}{key}{Style.RESET_ALL}: {value}")
+
+        print()
+
+
+def csp_result(results):
+    print(Fore.CYAN + "=== CSP Analysis ===")
+
+    if not results:
+        print(Fore.GREEN + "No CSP issues found.\n")
+        return
+
+    for count, result in enumerate(results, start=1):
+        color = severity_color(result["severity"])
+
+        print(f"({count}> {color}[{result['severity'].upper()}]{Style.RESET_ALL} {result['header']}")
+
+        if "value" in result:
+            print(f"    {Fore.GREEN}Value{Style.RESET_ALL}   : {result['value']}")
+
+        print(f"    {Fore.GREEN}Message{Style.RESET_ALL} : {result['message']}")
+
+    print()
+
+
+def cors_result(results):
+    print(Fore.CYAN + "=== CORS Analysis ===")
+
+    if not results:
+        print(Fore.GREEN + "No CORS issues found.\n")
+        return
+
+    for count, result in enumerate(results, start=1):
+        color = severity_color(result["severity"])
+
+        print(f"({count}> {color}[{result['severity'].upper()}]{Style.RESET_ALL} {result['header']}")
+
+        if "value" in result:
+            print(f"    {Fore.GREEN}Value{Style.RESET_ALL}   : {result['value']}")
+
+        print(f"    {Fore.GREEN}Message{Style.RESET_ALL} : {result['message']}")
+
+    print()
+
+
+def display_target(config):
+    print("=" * 60)
+    print(Fore.YELLOW + f"Target: {config['target']}\n")

akii-0.1.0/src/akii.egg-info/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: akii
+Version: 0.1.0
+Summary: HTTP header analyzer
+License-Expression: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.32.0
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: colorama>=0.4.6
+
+# AkII
+
+> A fast and lightweight HTTP security header analyzer.
+
+AkII is an open-source security tool for analyzing HTTP response headers and identifying common security misconfigurations, such as weak or missing security headers.
+
+> **⚠️ Early Development**
+>
+> AkII is in an early stage of development. Some features are still incomplete, and bugs are expected. The project is under active development, and new functionality will be added in future releases.
+
+## Features
+
+- Analyze HTTP security headers
+- Detect common CORS misconfigurations
+- Detect missing or insecure Content Security Policy (CSP)
+- Human-readable terminal output
+- JSON output for automation
+- Lightweight and extensible YAML-based rule engine
+
+## Why AkII?
+
+AkII is designed for speed, automation, and extensibility.
+
+AkII focuses on one task: analyzing HTTP security headers quickly and consistently.
+
+It is suitable for:
+
+- CI/CD pipelines
+- Security automation
+- Bug bounty workflows
+- Batch scanning with wordlists
+- Integration into custom tools
+
+## Installation
+
+### From PyPI (Recommended)
+
+```bash
+pipx install akii
+```
+
+or
+
+```bash
+pip install akii
+```
+
+### From Source
+
+```bash
+git clone https://github.com/MintTester-IO/AkII.git
+cd akii
+pip install -e .
+```
+
+## Uninstallation
+
+If you installed AkII with **pipx**:
+
+```bash
+pipx uninstall akii
+```
+
+If you installed AkII with **pip**:
+
+```bash
+pip uninstall akii
+```
+
+If you installed AkII from source using `pip install -e .`:
+
+```bash
+pip uninstall akii
+cd ..
+rm -rf akii
+```
+
+## Usage
+
+Scan a single target:
+
+```bash
+akii -T https://example.com
+```
+
+Scan multiple targets:
+
+```bash
+akii -w targets.txt
+```
+
+Show request headers:
+
+```bash
+akii -T https://example.com --request
+```
+
+Show response headers:
+
+```bash
+akii -T https://example.com --response
+```
+
+Verbose mode:
+
+```bash
+akii -T https://example.com --verbose
+```
+
+Save the report:
+
+```bash
+akii -T https://example.com -o report.txt
+```
+
+Export JSON:
+
+```bash
+akii -T https://example.com -jo report.txt
+```
+
+## Current Checks
+
+- Cross-Origin Resource Sharing (CORS)
+- Content Security Policy (CSP)
+
+More security header checks will be added in future releases.
+
+## Project Structure
+
+```
+src/akii/
+├── checks/      # Detection and analysis modules
+├── core/        # Controller, CLI, reporting
+├── http/        # HTTP client
+├── templates/   # YAML rule definitions
+└── ui/          # Terminal output
+```
+
+## Roadmap
+
+- HSTS analysis
+- Cookie analysis
+- Cache-Control analysis
+- Permissions-Policy analysis
+- Referrer-Policy analysis
+- HTML reports
+- Improved JSON reporting
+- Plugin system
+
+## Contributing
+
+Contributions are welcome.
+
+If you find a bug, have a feature request, or would like to improve AkII, please open an issue or submit a pull request.
+
+## License
+
+This project is licensed under the MIT License.

akii-0.1.0/src/akii.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+README.md
+pyproject.toml
+src/akii/__init__.py
+src/akii.egg-info/PKG-INFO
+src/akii.egg-info/SOURCES.txt
+src/akii.egg-info/dependency_links.txt
+src/akii.egg-info/entry_points.txt
+src/akii.egg-info/requires.txt
+src/akii.egg-info/top_level.txt
+src/akii/checks/__init__.py
+src/akii/checks/cache.py
+src/akii/checks/cookie.py
+src/akii/checks/cors.py
+src/akii/checks/csp.py
+src/akii/checks/hsts.py
+src/akii/core/__init__.py
+src/akii/core/controller.py
+src/akii/core/reporter.py
+src/akii/core/template_loader.py
+src/akii/core/cli/__init__.py
+src/akii/core/cli/main.py
+src/akii/core/cli/parser.py
+src/akii/core/flags/general.py
+src/akii/http/__init__.py
+src/akii/http/client.py
+src/akii/ui/__init__.py
+src/akii/ui/banner.py
+src/akii/ui/output.py

akii-0.1.0/src/akii.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

akii-0.1.0/src/akii.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+akii = akii.core.cli.main:main

akii-0.1.0/src/akii.egg-info/requires.txt

@@ -0,0 +1,3 @@
+requests>=2.32.0
+PyYAML>=6.0
+colorama>=0.4.6

akii-0.1.0/src/akii.egg-info/top_level.txt

@@ -0,0 +1 @@
+akii