thehardwarestore.ai

Nebular is a comprehensive Angular UI component library developed by Akveo. It provides over 40 reusable components (buttons, cards, tables, calendars, dialogs, etc.), a powerful theming engine with four built-in themes (default, dark, cosmic, corporate), and optional modules for authentication (password, OAuth2, Firebase) and role-based security. The repository is structured as a monorepo with multiple npm packages (@nebular/theme, @nebular/auth, @nebular/security, etc.), each with its own build configuration and tests. The library follows consistent patterns: all components use Angular's NgModule system, implement ControlValueAccessor for form integration, and leverage a custom overlay system built on Angular CDK for popups, tooltips, and modals. The codebase is well-organized with extensive unit tests and e2e tests, but shows signs of maintenance drift: the README explicitly states minimal active development (only Angular version bumps), many components still use deprecated Angular patterns (standalone: false, static ViewChild), and e2e tests rely on Protractor (deprecated). Despite this, the library remains functional and widely used, with a large set of documented examples and a dedicated documentation site.

Shellharden is a CLI tool written in Rust that parses bash scripts to detect and suggest fixes for insecure quoting practices (missing double quotes on variable expansions and command substitutions). It functions as a corrective syntax highlighter, outputting the script with color-coded syntax and background highlights for suggested changes. The tool supports modes: highlighting, diff, transform (apply changes), check (exit with code 2 if changes needed), and replace (in-place file modification). The core architecture is a stack-based state machine where each parsing context (command, argument, string, comment, heredoc, variable, etc.) is represented by a separate struct implementing the `Situation` trait. Input bytes are processed through a horizon buffer, and the machine outputs colored or transformed bytes. The code is self-contained with zero external Rust dependencies, relying only on the standard library. It includes a comprehensive test suite with unit tests for individual parsing states and integration tests using real bash scripts. The project demonstrates careful handling of bash's syntactic edge cases, such as nested substitutions, heredocs, associative arrays, and the complex quoting rules of backticks vs `$()`.

ROPgadget is a Python CLI security tool that statically scans executable binaries for ROP, JOP, and SYS gadgets. It discovers architecture-specific byte patterns (x86/x64, ARM/ARM64, MIPS, PowerPC, SPARC, RISC-V), disassembles candidate regions with Capstone, and outputs address/instruction listings. It supports ELF, PE, Mach-O, raw, and universal/fat binaries, and offers filtering by mnemonic, regex, bad bytes, address ranges, and call-preceded gadgets. For x86/x64 ELF targets it can also generate a Python exploit script that chains gadgets into a ROP payload.

Aspia is a comprehensive, cross-platform remote desktop and system administration suite. The codebase is decomposed into four primary components: a **host** (the machine being controlled), a **client** (the controlling machine), a **router** (session brokering and NAT traversal), and a **relay** (traffic forwarding). It supports Windows, Linux, macOS, and Android, with platform-specific implementations for screen capture (DXGI, X11, Wayland/PipeWire, KMS/DRM, Android MediaProjection), audio (WASAPI, PulseAudio, Oboe), input injection, and clipboard integration. The system uses encrypted communication with SRP authentication, X25519 key exchange, and AEAD ciphers (AES-256-GCM, ChaCha20-Poly1305) with key ratcheting. Beyond desktop sharing, it provides file transfer, text chat, remote terminal, task manager, system information collection, and video recording. The client features both a Qt-based desktop GUI and a custom Android UI built with native widgets. The router manages host discovery, two-factor authentication (TOTP), and relay session keys, while the relay handles peer-to-peer forwarding. The codebase is built with CMake, uses protobuf for messaging, and relies on libraries like asio, OpenSSL, libvpx, libyuv, and zstd.

This is a Symfony bundle that adds Cross-Origin Resource Sharing (CORS) headers to HTTP responses and handles CORS preflight OPTIONS requests. It intercepts kernel request and response events, applies configurable per-URL rules (origin matching, allowed methods/headers, credentials, private network access, forced origin values, etc.), and automatically adds a `Vary: Origin` header to cacheable responses. The bundle is well-structured with a clean provider/resolver pattern for configuration, supports Symfony 5.4 through 8.0 and PHP 7.2+, and includes full CI and static analysis. It is a mature, actively maintained library that solves a specific HTTP security concern in a robust and extensible manner.

This repository is the Python implementation of PowerView, a comprehensive Active Directory (AD) security assessment and exploitation tool. It provides a feature-rich CLI (with an interactive shell), a web-based UI (Flask + vanilla JS), and a Model Context Protocol (MCP) server for AI agent integration. The tool enumerates AD objects (users, groups, computers, GPOs, trusts, certificates, DNS, SMB shares, etc.), identifies security vulnerabilities (kerberoasting, AS-REP roasting, shadow credentials, ACL abuse, certificate template misconfigurations), and supports active exploitation (DACL modification, RBCD, coercion attacks, SMB file operations). It is designed for red team operations and AD security audits. The architecture is a monolith centered on a large `PowerView` class (in `powerview.py`) that orchestrates all commands and dispatches to specialized modules (e.g., `kerberoast.py`, `ca.py`, `exchange.py`, `ldapattack.py`). It supports both standard LDAP and a custom implementation of Microsoft's Active Directory Web Services (ADWS) protocol (SOAP over .NET Message Framing and NegotiateStream), enabling operations without conventional LDAP. The tool leverages Impacket for low-level Windows protocols (SMB, RPC, Kerberos) and includes a plugin system with decorator-based registration and before/after hooks. The web front-end offers interactive graph visualization, object exploration, and real-time command history, while the MCP server exposes AD operations to AI assistants. Key data flows involve LDAP/ADWS queries for object enumeration, SMB/RPC sessions for remote system interaction, and Kerberos tickets for authentication attacks. External dependencies include `ldap3` (forked), `impacket` (forked), `dsinternals`, `flask`, `werkzeug`, and client-side libraries (Cytoscape.js, Alpine.js, Tailwind CSS). The codebase is large and tightly coupled in places, but the custom ADWS implementation, plugin system, and vulnerability detection engine are notable achievements that could be extracted and reused.

CloudDM is a database management platform providing unified access to multiple database systems. It features a web-based console interface built with Vue.js and a Java/Spring Boot backend with a plugin architecture for database drivers. The platform combines database querying, management, access control, SQL auditing, CI/CD capabilities, and workflow automation in a single system. The architecture follows a modular, layered design with clear separation between frontend, backend API, service layer, data access layer, and plugin system. Key features include multi-database support (MySQL, PostgreSQL, Oracle, SQL Server, MongoDB, Redis, etc.), SQL parsing and analysis, security rule engine, and extensibility through plugins.

ClawGuard is a security application designed to protect AI agent ecosystems through static code analysis, runtime monitoring, and sandboxed execution. The backend is a FastAPI server providing authentication (JWT), a code security check pipeline (AST scanning + sandbox execution with sys.settrace monitoring), and audit log storage in SQLite. The frontend is a single-page HTML dashboard with Chinese/English i18n, simulating a defense matrix with real-time feedback. The system demonstrates a multi-layered defense: static prevention (AST blacklist), dynamic detection (monkey-patched builtins, runtime behavior monitoring), and mitigation (timeout, permission errors). It is a well-structured, self-contained application with clear separation of concerns, though the frontend is monolithic. The code quality is strong, with reusable components in the core modules, but the overall architecture is tightly coupled to the specific security policy.

This repository provides a set of command-line tools (gvm-cli, gvm-script, gvm-pyshell) for remotely controlling Greenbone Vulnerability Management (GVM) installations via the Greenbone Management Protocol (GMP) and Open Scanner Protocol (OSP). The tools allow administrators to send raw XML commands, execute Python scripts that interact with the GMP/OSP API, and run an interactive Python shell with pre-configured connection objects. The architecture is modular: a parser module handles argument parsing and connection creation, a config module reads user configuration, a helper module provides utilities like authentication prompting and table formatting, and separate modules implement each CLI tool. The primary data flow is from the user (via CLI arguments or script) through the connection layer to the GVM daemon, with responses returned as XML or formatted output. External dependencies include the python-gvm library for protocol handling, and optionally SSH keys for SSH connections. The codebase is well-structured with clear separation of concerns, comprehensive test coverage, and extensive example scripts demonstrating common administrative tasks such as listing tasks, creating targets, exporting reports, and managing alerts. The project follows semantic versioning, uses modern Python packaging with pyproject.toml and uv, and includes CI/CD pipelines for testing, linting, and deployment to PyPI and container registries. While primarily a management tool, it also includes reusable components like a table formatter, connection factory, and authentication helper that could be extracted for other projects.

This repository is a large collection of Bash scripts that automate the deployment, configuration, and update of self-hosted services on Proxmox VE, primarily through LXC containers and VMs. It is a provisioning and automation framework rather than a runtime application: each ct/*.sh script declares resource variables (CPU, RAM, disk, OS template) and an optional update_script(), while install/*.sh scripts run inside an existing container to install a specific application. Usage is typically a one-line curl command executed as root on the Proxmox host, after which the script creates a container/VM, installs dependencies, generates credentials, writes systemd units or OpenRC init scripts, and configures databases and reverse proxies. The architecture is layered: hundreds of app-specific scripts wrap a smaller set of shared Bash function libraries in the misc/ directory (build.func, install.func, vm-core.func, core.func, error_handler.func). These shared functions handle common operations such as fetching GitHub releases, setting up language runtimes, creating databases, backing up configs before updates, and standardizing error handling. Update flows generally stop the service, back up configuration/data, fetch the latest release, restore the backup, run migrations, and restart the service. This consistency is the project's main strength and makes adding a new container recipe relatively straightforward. Weaknesses are typical of a large community-driven shell-script collection: no unit tests, heavy reliance on third-party installers fetched via curl|bash, some hardcoded versions, and external dependencies on GitHub release asset names and remote core-library URLs. Many scripts assume Debian/Ubuntu or Alpine bases and run as root with no signature verification. Despite these risks, the codebase is actively maintained, consistently formatted, and the shared function libraries are practical examples of reusable Bash abstractions for Proxmox automation.

OneForAll is a comprehensive subdomain enumeration and reconnaissance tool designed for security researchers and penetration testers. It aggregates subdomains from over 60 passive sources (certificate transparency logs, DNS datasets, search engines, threat intelligence feeds, and web crawlers), performs active brute-forcing via massdns, and enriches results with DNS resolution, HTTP probing, CDN detection, wildcard filtering, and subdomain takeover risk assessment. The tool is built as a modular Python CLI application, with each data source implemented as an independent plugin inheriting from base classes in `common/`. Output is stored in a SQLite database and can be exported to CSV, JSON, XLSX, and other formats. While primarily an application, the repository also includes curated data files (subdomain wordlists, CDN CIDR ranges, cloud service fingerprints) that are valuable for security research.

simplewall is a native Windows desktop application that functions as a personal firewall using the Windows Filtering Platform (WFP). It controls per-application network access via user-defined rules and blocklists, including built-in Microsoft spy/telemetry lists. The application provides a full GUI with tabs for applications, services, UWP packages, rules, network connections, and logs, along with a tray icon, notification popups, and a rule editor. It logs allowed/blocked connections to a CSV file and supports real-time network monitoring via TCP/UDP statistics (including ETW-based UDP accounting). Profiles are stored in XML format with optional compression and AES encryption, and filters can be installed permanently, temporarily, or at boot time. The architecture is a monolithic C/C++ Win32 application with a custom utility library ("routine") as a submodule. Key modules handle WFP filter lifecycle, WFP net event subscription, network connection enumeration, security descriptor management, and UI controls (listview, search bar, notifications). The code demonstrates deep Windows internals knowledge, including WFP version-specific callbacks, ETW session management, cryptographic hashing, and digital signature verification. While the application is actively maintained (latest beta v3.9.1 as of July 2026), it is tightly coupled to Windows APIs and contains workarounds for historical Microsoft bugs, leading to moderate technical drift risk. Strengths include comprehensive WFP integration, robust logging, and a well-organized codebase with reusable patterns for WFP security (ACL management) and ETW-based UDP monitoring. Weaknesses include reliance on a private library submodule, hardcoded service/port lookup tables, and Windows version-specific branches that may need adjustment for future releases. The project is suitable for developers seeking a reference implementation for WFP firewall development or a reliable Windows filtering tool.

This repository provides a Pluggable Authentication Module (PAM) for two-factor authentication using TOTP (RFC 6238) and HOTP (RFC 4226) one-time passwords. It consists of a PAM shared library (`pam_google_authenticator.so`) that integrates with any PAM-aware service (SSH, login, etc.) to require a verification code in addition to the user's password, and a command-line tool (`google-authenticator`) for generating secret keys and configuring per-user state files. The implementation is written in C using autotools for building, and includes self-contained cryptographic primitives (Base32 encoding, HMAC-SHA1, SHA-1) that are also reused across the PAM module and the CLI tool. The code is well-structured, with careful attention to security (explicit memory zeroing, file permission checks, rate limiting, and reuse prevention). While the build system and CI (Travis CI) are somewhat dated, the core functionality is mature and actively maintained.

msldap is a Python library and CLI tool for interacting with Microsoft Active Directory via LDAP. It provides both a low-level async connection (MSLDAPClientConnection) and a high-level client (MSLDAPClient) with convenience methods for enumerating users, computers, groups, GPOs, trusts, and more. The library supports multiple authentication methods (NTLM, Kerberos, simple, SSPI), LDAPS, SOCKS proxy, and includes an interactive console client (msldap) and a BloodHound collector (msldap-bloodhound). It also features ADCS vulnerability scanning, shadow credentials, LAPS extraction, DNS record manipulation, and an LDAP relay server. The codebase is well-organized with a modular architecture, extensive test suite (offline and live interop tests), and several reusable components such as a custom ASN.1 packetizer, LDAP filter parser, and binary structure parser. However, it has some known bugs (7 registered in known_failures.yml), vendored dependencies (asciitree, aiocmd) that may drift from upstream, and a few code quality issues (typos, dead code). Overall, it is a solid, feature-rich tool for AD security assessments.

ghtkn is a Go CLI and local agent daemon that obtains short-lived GitHub App User Access Tokens via the OAuth device flow, replacing long-lived PATs and CLI OAuth tokens. The Cobra-based CLI exposes commands such as init, auth, get, exec, git-credential, revoke, agent start/stop/lock/unlock/status/reset, info, docs, json-schema, and completion. The agent runs as a background daemon and speaks a JSON-lines protocol over a local socket with GET, SET, UNLOCK, STATUS, and STOP commands. Tokens are stored encrypted at rest using AES-256-GCM with an Argon2id-derived key-encryption key, one file per client ID with 0600 permissions and atomic writes.

This repository is a Kotlin/Java library providing Certificate Transparency (CT) verification for Android and JVM applications. It prevents man-in-the-middle attacks by validating TLS certificates against public CT logs. The library offers multiple integration approaches: Java Security Provider, OkHttp interceptors, TrustManager and HostnameVerifier wrappers for HttpURLConnection/Volley/WebView, and direct API usage. Key features include CT log list fetching and parsing, SCT verification, optional CRL-based certificate revocation checking, and configurable caching. The architecture is modular with a core library, Android-specific extensions, and a sample application demonstrating all integration methods. The code employs modern Kotlin idioms (coroutines, sealed classes, builder patterns) and maintains strong separation of concerns between network fetching, policy enforcement, chain cleaning, and verification logic.

This repository is the `express-jwt` npm package, a widely-used Express.js middleware for validating JSON Web Tokens (JWTs). The core function `expressjwt(options)` returns a middleware that extracts the JWT from the request (defaulting to the Authorization Bearer header), decodes it, verifies its signature using a provided secret or async callback, checks standard claims like audience and issuer, and optionally checks token revocation. The decoded payload is attached to `req.auth`. The middleware supports CORS preflight handling and integrates with `express-unless` for conditional skipping. It is a focused, well-structured library with clean TypeScript types and a simple architecture. The code is actively maintained by Auth0 with automated CI/CD for releases and testing across multiple Node.js versions. The primary reusable component is a generic deep property setter utility.

This is a single-file Bash script that performs a comprehensive security and performance audit of a Linux VPS. It checks SSH configuration, firewall status, intrusion prevention systems (Fail2ban/CrowdSec), failed login attempts, system updates, running services, open ports, disk/memory/CPU usage, sudo logging, password policy, and SUID files. The script outputs color-coded PASS/WARN/FAIL results to the console and writes a detailed timestamped report to a file. It is designed for Ubuntu/Debian-based systems and requires root or sudo privileges. The architecture is a monolithic Bash script with no external dependencies beyond standard Linux utilities and optional tools like UFW, Fail2ban, and Docker. The code is well-structured with configurable thresholds and file paths, demonstrating solid Bash scripting practices. However, it is not designed for reuse as a library; it is a standalone tool.