LSA Whisperer BOF is a Cobalt Strike Beacon Object File (BOF) port of Evan McBroom's LSA Whisperer tool, enabling red team operators to interact with Windows authentication packages (MSV1_0, Kerberos, CloudAP) through legitimate LSA client APIs (LsaCallAuthenticationPackage). It recovers DPAPI credential keys (including under Credential Guard), dumps Kerberos tickets as base64 .kirbi blobs, performs selective ticket purging, extracts Entra ID/AD FS SSO cookies, and generates NTLMv1 responses for hash cracking—all without opening handles to LSASS or touching process memory. The architecture comprises three independent BOF modules (msv1_0, kerberos, cloudap) sharing a common LSA communication layer and comprehensive header definitions for undocumented LSA structures. The code is well-structured, handles privilege separation (untrusted vs. trusted LSA connections), and provides detailed error messages. It targets red team operations and requires Cobalt Strike for execution.
The AN2Linux Client is an Android application designed to forward device notifications to a Linux desktop companion server over secure TLS connections. It intercepts notifications via Android's NotificationListenerService, applies user-configured filters (per-app and global), and transmits notification data to configured servers (Wi-Fi, mobile, or Bluetooth) using certificate-based authentication. The architecture combines Android components (Activities, Services, BroadcastReceivers) with modern patterns like ViewModels/LiveData for UI state management, custom preferences for advanced settings, and isolated cryptographic helpers for TLS operations. Key features include foreground service execution to bypass background restrictions, boot-time auto-start, granular notification filtering, and support for multiple connection types with SSID whitelisting for Wi-Fi.
This repository contains the client-side code for EASYME.md, a web-based markdown editor designed for creating and sharing README files. The application features a split-pane interface with a live markdown preview, a customizable toolbar for applying formatting, and functionality to share documents via a unique URL. Built with React, Redux, and Emotion, it demonstrates a well-structured single-page application with clear separation of concerns. The editor uses a textarea for input and leverages the `text-field-edit` library for precise text manipulations, enabling features like inserting text at the cursor position, wrapping selections, and handling keyboard shortcuts for common markdown syntax. State management is handled by Redux Toolkit with Redux Saga for side effects, such as fetching saved documents from a backend API. The application also supports offline drafting via localStorage and sharing via URL hash compression using `lz-string`. Key components include a dynamic toolbar with buttons for bold, italic, lists, tables, and more, each implemented as isolated, reusable components. The utility modules for URL sharing and draft storage are particularly noteworthy for their potential reuse in other projects. Despite some dependencies being slightly outdated, the codebase remains functional and maintainable.
AnsPress is a full-featured WordPress plugin that adds a complete question-and-answer community system similar to Stack Exchange. It introduces custom post types for `question` and `answer`, custom taxonomies for categories and tags, and multiple custom database tables (`ap_votes`, `ap_views`, `ap_reputations`, `ap_activity`, `ap_subscribers`, `ap_notifications`) to support voting, reputation, activity tracking, subscriptions, and notifications. The architecture is modular: core classes handle forms (input, textarea, editor, upload, etc.), AJAX handlers, query logic, theme integration, and admin management. An addon system allows optional features like reputation, email notifications, reCAPTCHA, syntax highlighting, BuddyPress integration, and more to be toggled on/off. The front-end uses Backbone.js for dynamic interactions (voting, comment approval, answer selection) and SCSS for styling. The plugin is extensible via WordPress hooks and filters, and it provides a CLI interface via WP-CLI. Key entry points include the main plugin bootstrap file `anspress-question-answer.php`, the autoloader `loader.php`, and core include files in `includes/` (e.g., `api.php`, `process-form.php`, `qaquery.php`). Data flows center around user actions: questions and answers are submitted via forms (processed by `AP_Form_Hooks` and the form field library), stored as WordPress custom post types with additional meta in `ap_qameta`, and retrieved using custom query classes (`Question_Query`, `Answers_Query`) that handle pagination, prefetching, and ordering. Voting, flagging, and view counts are stored in dedicated tables. Activities and notifications are logged on key events (new question, answer, comment, vote) and consumed by the front-end or email addon. The system relies on WordPress core, optional plugins (BuddyPress, Akismet), and bundled third-party libraries (SyntaxHighlighter, ReCaptcha). The plugin is production-ready with extensive PHPUnit test coverage (unit and integration tests using BrainMonkey and Yoast WPTestUtils) covering core functions, addons, AJAX, and admin panels. It uses modern PHP 8.0 and follows WordPress coding standards in most places, though some legacy patterns (global functions, direct `$wpdb` calls, bundled outdated libraries) introduce moderate technical drift.
SwiftyFitsize is an iOS SDK that provides screen size adaptation for UI elements. It allows developers to define UI dimensions based on a reference design size and automatically scales those dimensions to fit different screen sizes, with special handling for iPhone vs iPad differences and safe area considerations (notch, home indicator). The library offers both operator-based syntax (~ value) and function-based syntax for flexibility, plus Interface Builder support through UIKit extensions. It includes a property wrapper for reusable adapted values and maintains full Objective-C compatibility through a bridging header.
Etl-engine is a Java-based ETL (Extract, Transform, Load) library designed for high-performance data synchronization. It provides a lightweight, extensible framework built around three core components: Node (data sources/destinations/transformations), Pipe (thread-safe buffered queues for data transfer), and Dataflow (orchestrator for pipeline execution). The library supports various data sources including JDBC databases (PostgreSQL, MySQL, Oracle, ClickHouse, DuckDB) and file outputs, with built-in capabilities for batch processing, automatic error handling/retry, and detailed logging. The architecture follows a producer-consumer pattern using Java's concurrency utilities, enabling efficient parallel data processing. Sample implementations demonstrate common ETL scenarios like database-to-database transfers, conditional data routing, and value transformation.
IgGM is a generative foundation model for antibody and nanobody design, implemented as a deep learning library with a command-line interface. The system performs tasks such as CDR loop design, framework region redesign (humanization), inverse design from complex structures, affinity maturation, and structure prediction. It uses a diffusion-based approach to co-design amino acid sequences and 3D backbone structures, leveraging an ESM2-based protein language model, Evoformer blocks with triangular attention, invariant point attention, and a structure module similar to AlphaFold2. The pipeline is orchestrated by the `AbDesigner` class and invoked via the `design.py` script, accepting PDB and FASTA inputs and generating output sequences and structures. The repository includes well-structured reusable components for rigid-body transformations (Rotation, Rigid), PDB parsing, coordinate conversion, and diffusion schedules, though some research artifacts (misspellings, commented code) and dependency pinning to older PyTorch/CUDA versions indicate moderate technical drift.
GlucoDataHandler is a multi-platform Android application (phone, Wear OS, Android Auto) that aggregates continuous glucose monitoring (CGM) data from numerous sources including LibreLinkUp, Dexcom Share, Medtrum, Nightscout, xDrip+, Juggluco, AndroidAPS, and notification reading from other diabetes apps. It presents glucose values, trends, deltas, IOB/COB, and historical charts via home screen widgets, lock screen overlays, Always-On Display, Wear OS complications and tiles, and Android Auto media player. The app features a highly configurable alarm system with per-type sound/vibration/snooze settings and full-screen notifications. The codebase is organized into four Gradle modules: `common` (shared library), `mobile` (phone app), `wear` (Wear OS app), and `auto` (Android Auto companion). The common module contains core data handling, a Room database for glucose history, a custom event bus (InternalNotifier), an abstract background task framework (BackgroundTask/BackgroundTaskService), and a chart rendering pipeline with bitmap caching (ChartBitmapHandler, BitmapPool). The mobile and wear modules provide platform-specific services, activities, preferences, and UI components. Health Connect integration and a local xDrip-compatible HTTP server are also included. The application demonstrates solid engineering with reusable patterns: the notifier pattern decouples data sources from UI updates; the background task framework abstracts periodic polling with alarm-based scheduling; and the bitmap pool reduces allocation pressure for frequent widget/complication renders. However, the codebase carries significant integration surface with third-party CGM services and deprecated API usages, posing medium technical drift risk. Test coverage is limited. The project is actively maintained with recent commits and open issue triage.
This repository is a curated collection of rules for the ananicy-cpp daemon, which automatically adjusts process nice/ionice/scheduling priorities on Linux. It is primarily a dataset of process name to type mappings, organized by category (audio-video, browsers, games, desktop environments, services, tools, etc.), with additional cgroup CPU quota definitions. The rules are manually curated by the community and cover thousands of applications, including Linux native and Wine/Proton games, with detailed per-game executable entries. The repository includes JSON schemas for validation, a linting script, a sorting script for game rules, and a Makefile for installation. It is actively maintained and serves as the default ruleset for the CachyOS Linux distribution's ananicy-cpp package. No ETL pipelines or analytical models are present; the primary data product is the ruleset itself.
BrewServicesManager is a native macOS menu bar application built with SwiftUI and Swift 6 concurrency that provides a graphical interface for managing Homebrew services (start, stop, restart, view status, detect ports, configure service links). The architecture follows a SwiftUI-first pattern with an actor-based `BrewServicesClient` for serialized shell command execution against Homebrew, an `@Observable` `ServicesStore` as the central state manager, and a modular view hierarchy for the menu bar interface. It integrates with Sparkle for automatic updates, uses `NSAppleScript` for privilege escalation when managing system-level services, and employs `lsof`/`pgrep` for port detection. External dependencies include Homebrew, Sparkle framework, and standard macOS command-line tools. The code demonstrates modern Swift practices including strict concurrency, `@Observable` classes, and clean reactively-driven UI with `@Binding` and `@Environment` injection.
This repository is a specialized tool for automated C code permutation to match a target compiled binary, primarily used in video game decompilation projects (e.g., Nintendo 64). The core loop reads a C source file and a target object file, then repeatedly mutates the C code using a set of predefined random transformations, compiles it, disassembles the output, and scores the resulting assembly against the target. The goal is to produce a C source that compiles to identical or nearly identical assembly, reducing manual effort in reverse engineering. The architecture is a Python CLI application with support for multi-threading and distributed computing. The main entry points are `permuter.py` (local mode), `import.py` (project setup), and `pah.py` (network client for distributed 'permuter@home'). The system relies on a vendored fork of pycparser for C parsing and AST manipulation, and it integrates with external tools: a C compiler (GCC, IDO, or MWCC), `objdump` for disassembly, and optionally Docker for sandboxed remote evaluation. A Rust server (`src/net/controller`) manages the distributed network, and a Go systray helper provides a system tray icon for the network client. Data flows are iterative: the tool seeds a candidate, applies one or more random permutations (e.g., introducing temporaries, reordering declarations, transforming expressions), compiles the result, extracts assembly, scores it using a diff-based algorithm, and keeps the best candidate. The process repeats until a perfect match is found or the user stops it. The project demonstrates high craftsmanship in its modular design, with clean abstractions for permutations, scoring, AST utilities, and networking. The vendored pycparser is heavily patched for GNU C extensions, and the custom stubs ensure type safety.
llama.ui is a browser-based chat interface for local and cloud LLM inference. It is not a data/research repository: it is a React 18 + TypeScript + Vite 7 single-page application packaged as a PWA with offline storage. The app connects to llama.cpp, LM Studio, Ollama, vLLM, and OpenAI-compatible cloud providers through a provider-factory abstraction, streams completions over SSE, and persists conversation history entirely client-side in IndexedDB via Dexie. Entry points are src/main.tsx and src/App.tsx, with routes for chat, settings, and welcome; state is managed through React Context stores (app, chat, inference, modal).
This repository contains the LatentNeeds-Bench benchmark and evaluation framework for proactive AI demand detection, as described in the research paper 'Pask: Toward Intent-Aware Proactive Agents with Long-Term Memory'. The project focuses on creating a benchmark to evaluate whether AI models can detect latent user needs in ongoing conversations without explicit prompting. It includes a comprehensive data processing pipeline that transforms raw speech transcripts into annotated benchmark datasets, an evaluation framework to test various LLMs on this benchmark, and tools to generate research paper tables and figures. The system implements the DD-MM-PAS paradigm (Demand Detection, Memory Modeling, Proactive Agent System) with IntentFlow as the specialized demand detection model.
This repository is the content generation and build system for the interactive textbook *Mathematics in Lean*. It is a hybrid project: primarily a set of Python scripts and a Lean 4 project that together produce the textbook in multiple formats (Sphinx RST/HTML/PDF), as well as a separate user repository with exercise stubs and solutions. The core pipeline parses Lean source files annotated with custom directives (`TEXT`, `EXAMPLES`, `SOLUTIONS`) via `scripts/mkdoc.py` to generate textbook prose and Lean exercise files. A Sphinx build then produces the final HTML/PDF documentation. The Lean source files themselves cover mathematics from basic arithmetic to measure theory, heavily leveraging the Mathlib library. The repository includes CI/CD workflows (GitHub Actions), developer environments (Devcontainers, Gitpod), and testing scripts that verify the generated Lean files compile. While not a traditional application, it functions as a specialized toolchain for creating and deploying formal mathematics educational content.
This repository implements AMD's MxGPU virtualization solution, providing SR-IOV support for AMD GPUs (MI200, MI300, Navi32). It consists of a kernel module (GIM) that manages virtual functions, a core library (libgv) for hardware abstraction and RAS, and a user-space system management interface (SMI) with CLI and Python bindings. The architecture is layered: the kernel driver (gim/) communicates with hardware and exposes IOCTLs; libgv/ provides hardware-specific implementations via function pointer tables; smi-lib/ provides a unified API for monitoring, partitioning, RAS, and NIC management. Key entry points include the GIM kernel module (gim/gim_shim/gim_drv.c), the SMI CLI (smi-lib/cli/cpp/src/smi_cli_main.cpp), and the SMI library (smi-lib/src/amdsmi.c). Data flows involve PF-VF mailbox communication, RAS error logging via CPER, and telemetry collection through SMU firmware interfaces. External dependencies include Linux kernel headers, DKMS, and optional NIC libraries. The codebase is large and professionally structured, with extensive hardware abstraction layers, unit tests, and packaging scripts, though it carries maintenance risks from ASIC-specific duplication and embedded firmware blobs.
This repository provides theme configurations for the Hyprlock screen locker. It includes an example configuration file (hyprlock.conf) and a Tera template (hyprlock.tera) used to generate four color theme files (frappe, latte, macchiato, mocha) via the whiskers tool. The themes define color variables in the format expected by Hyprlock. The repository is lightweight and focuses on delivering ready-to-use themes, with a generation script (justfile) for maintaining the themes. The core functionality lies in the templating system that allows easy creation of new color schemes by defining flavor data.
Seek is a React Native mobile application for identifying plants, animals, and fungi using the device camera and on-device machine learning (InatVision). It allows users to capture photos, receive species identifications, save observations locally via Realm, and optionally post them to the iNaturalist citizen science platform. The app includes gamification features such as badges, levels, monthly challenges, and a year-in-review recap. It integrates with iNaturalist APIs for authentication, species data, range maps, and seasonality charts. The architecture is a monolithic React Native app with multiple Context providers for state management, React Navigation for routing, and a variety of native modules. The codebase is well-structured with TypeScript, has CI/CD pipelines, and uses snapshot tests. However, it has technical drift from patched dependencies, hardcoded monthly challenge content, and some tightly coupled components. Overall, it is a solid, actively maintained mobile app with moderate reusability of its UI primitives and custom hooks.
This is the OCA/social repository, a collection of 15 Odoo addon modules for Odoo 18.0 that extend the Odoo Discuss and mail systems with external messaging integrations and social profile features. The core module, `mail_gateway`, provides an abstract framework for integrating external chat platforms (Telegram, WhatsApp, Instagram) into Odoo Discuss via webhooks, enabling bidirectional communication. Concrete gateway modules (`mail_gateway_telegram`, `mail_gateway_whatsapp`, `mail_gateway_instagram`, and `mail_gateway_telegram_standalone`) implement provider-specific APIs, including message sending, template management (WhatsApp), and webhook verification. Additional modules add social media profile fields to partners and companies (LinkedIn, Mastodon), audit activity cancellations and unlinks, control mention suggestions, route unhandled emails to a default thread, and extend marketing campaigns with budget tracking. The repository follows standard OCA addon structure with Python models, XML views, OWL/JavaScript component patches, wizards, security rules, and translations. It is not a standalone application but a set of modules designed to be installed in an Odoo instance.
monkeSearch is a macOS-native file search tool that uses a local LLM to parse natural language queries into structured search parameters, then executes Spotlight searches via PyObjC. The system breaks queries into file type indicators (with specificity detection), temporal expressions, and residual keywords, converting them to NSPredicates using UTIs for file type matching and date comparisons for temporal filtering. It features a clean separation between LLM-based query parsing (query_gen.py) and Spotlight execution (parser.py), with the former being particularly well-engineered for reuse. The tool is designed for offline, agentic use with no cloud dependencies, targeting low-resource environments.
This is a standalone web UI for Midjourney image generation, built as a Next.js 14 application. It provides a prompt editor, image preview with upscale/variant/reroll actions, a task history list, and settings to configure a midjourney-proxy service. The app can run standalone or be embedded as a LobeChat plugin via an iframe. It uses React with Zustand for state management, SWR for data fetching, Immer for immutable state updates, and antd-style for theming. The backend consists of two API routes: one proxies requests to the midjourney-proxy service, and another uploads images to Imgur. The codebase is well-structured with clean separation of concerns, i18n support, and responsive design. While the application is functionally straightforward, it demonstrates solid engineering practices including pure reducer functions with unit tests, typed state management, and a modular layout system.