CPANscan

Crypt::OpenSSL::X509 is a Perl wrapper around OpenSSL’s X.509 functionality that lets you load certificates from files or strings and inspect them from Perl code. It provides easy access to common certificate data such as subject and issuer names, serial number, validity window, public key details (RSA modulus and exponent or EC curve), fingerprints, email addresses and Subject Alternative Names, and X.509 extensions, and can emit PEM or DER output. The module is tested to work across a range of OpenSSL releases (including OpenSSL 1.0, 1.1, 3.x and 4.x) and LibreSSL, so it is useful for scripts and tools that need to parse, display, or check certificates for expiry and attributes. The recent 2.1.2 bugfix ensures extension lookups are kept per certificate instance rather than shared across objects, so you should update if you rely on extension queries in long-running processes.

Monitoring::Sneck is a small utility for running Nagios-style checks on a host and exposing the results in LibreNMS-friendly JSON via SNMP. You define environment variables and named checks in a simple text config, the tool runs each command, captures exit codes, output and timings, and returns a structured hash with totals for OK, warning, critical, unknown and errored checks plus per-check details and optional debug entries. It is intended to be used via the supplied sneck script from snmpd or cron rather than as a general-purpose library and supports debug-only checks, including the raw config in output, and options for quieter operation and locking. Recent releases added quiet and locking flags, fixed a missing Proc::PID::File dependency, and increased test coverage.

Lilith is a Perl helper for ingesting Suricata, Sagan, and CAPE EVE JSON logs into a PostgreSQL backend and for querying those stored alerts. You configure it with a DBI DSN and credentials and it can create the necessary tables, read multiple named EVE files or instances, and apply ignore lists for rule IDs and classes while importing. It exposes a run method to process files, an extend helper for time-based lookups, and a search wrapper that makes it easy to filter events by time range, IP, port, rule id, signature, hashes, host, instance, and other common fields without writing raw SQL. The module also provides utilities to convert alert classes into short or SNMP-friendly names. Use Lilith if you want a simple Perl-based bridge between IDS/analysis JSON output and a queryable PostgreSQL store for forensic, monitoring, or SIEM workflows.

SPVM::Regex brings fast, safe regular expressions to SPVM by wrapping Google’s RE2 engine and exposing a Regex class for compiling patterns and running matches, replacements and splits. It also includes a Re convenience interface for a more Perl-like m/s/... style usage. The module supports capturing groups, callback-based replacements, global and offset-limited operations, UTF-8 matches, and in-place replacements via mutable string references, and split will include captured separators when the pattern uses parentheses. If you use SPVM and need reliable, RE2-backed regex features rather than the full Perl regex dialect, this module is a good fit. Recent releases added MSVC support and fixed macOS C++ build issues while updating minimum SPVM and SPVM::Resource::RE2 requirements.

SPVM::Resource::RE2 packages Google's RE2 regular expression engine as a resource for SPVM so you can include RE2 headers and call RE2 APIs from SPVM native C++ code. It bundles the RE2 source and headers (C++17) and integrates via a simple config call like config->use_resource('Resource::RE2'), allowing native methods to invoke functions such as RE2::PartialMatch for fast, safe, non‑backtracking regex matching suited to large or untrusted input. The module is aimed at SPVM developers who need a robust, high‑performance regex engine without embedding RE2 themselves and is distributed under the MIT license. Recent updates improved Windows support by adding MSVC compatibility and the -DNOMINMAX build flag and trimmed the bundled sources for a leaner build.

SPVM::R brings a large subset of R-style numeric and data tools into the SPVM/Perl world so you can work with vectors, matrices, and data frames using familiar R-like operations. It provides N-dimensional arrays in many primitive and complex types, vectorized math and trig functions, matrix algebra, NA handling, sequence and repetition helpers, slicing, ordering and sorting, and a DataFrame API with conditional row selection and column operations. The module is useful to Perl developers who want to perform array-based numerical computing or manipulate tabular data without leaving SPVM, and it includes examples, a tutorial, and a GitHub repository for hands-on guidance.

SPVM::MIME::Base64 is a straightforward SPVM implementation of MIME::Base64 that provides simple class methods to Base64-encode and decode data, making it easy to convert binary or text blobs to and from the well known Base64 text form. Its API includes encode_base64 and decode_base64 plus fast helpers to compute the encoded or decoded length without performing the full conversion, and encode_base64 accepts an optional line-ending argument and defaults to wrapping at 76 characters unless you pass an empty string. The decoder silently ignores non-Base64 characters and stops at padding, and all methods will raise an exception if given an undefined input. The module is actively maintained, released under the MIT license, and recent updates add MSVC support and require a recent SPVM runtime.

SPVM::Math is a thin, high-performance binding to the C math and complex libraries that exposes the standard math.h and complex.h routines as static class methods for SPVM/Perl code. It gives you familiar functions for trigonometry, exponentials, logarithms, rounding, classification of floats, constants like PI and E, special values such as NAN and INFINITY, and full complex arithmetic with float and double variants plus helpers to build and manipulate complex numbers. Most calls map directly to their C counterparts for predictable behavior and speed. A few routines that return extra values require you to pass a defined reference for the output parts or they will raise an exception and the module is distributed under the MIT license.

Perl::Critic::PJCJ provides a small set of Perl::Critic policies to help Perl developers keep code style consistent and readable by enforcing predictable quoting and line length practices. It includes a RequireConsistentQuoting policy that encourages minimal punctuation, prefers interpolated strings where appropriate, and standardizes choice of delimiters so string literals look uniform across a codebase. It also provides ProhibitLongLines to enforce a configurable maximum line length (default 80) with options for per-file overrides via .gitattributes and pattern-based exemptions for intentionally long lines. Recent releases fixed multi-byte handling so line length is now measured in characters rather than octets, avoiding false positives with UTF-8 source, and added other practical refinements for pragmas and quoting edge cases. If you want automated, configurable checks to keep Perl source tidy and consistent, this module is a lightweight, focused addition to a Perl::Critic setup.

SPVM::Digest::SHA is an SPVM-native port of Perl's Digest::SHA that implements the SHA family of hash algorithms and their HMAC variants, including SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224 and SHA-512/256. It offers simple class methods for one-shot hashing and HMACs with outputs as raw binary, hexadecimal or Base64, and an object-oriented interface for incremental hashing via new, add, clone and digest/hexdigest/b64digest. The module is a drop-in style utility for checksums, data integrity, message digests and HMAC-based authentication in SPVM applications and is actively maintained; recent releases added MSVC support and updated the SPVM version requirement to 0.990191 for improved portability and compatibility.

Crypt::OpenSSL3 is a modern Perl wrapper that gives your Perl code direct access to OpenSSL cryptography and TLS features. It breaks OpenSSL functionality into focused submodules, for example SSL for TLS connections, PKey for asymmetric keys, Cipher for symmetric ciphers, MD for digests, MAC for message authentication codes, KDF for key derivation and X509 for certificate handling. The top-level distribution itself mainly offers error handling and build-configuration introspection so you can query the OpenSSL version and how it was built on your system. Use this module when you need up-to-date, low-level access to OpenSSL primitives from Perl rather than a higher-level abstraction.

SPVM::Digest::MD5 provides MD5 hashing for SPVM programs and mirrors Perl's Digest::MD5 API. You can compute a one-shot hash with the class methods md5 and md5_hex which return the 16-byte binary digest or a 32-character lowercase hexadecimal string respectively. For streaming data use the object interface: create an instance with new, append chunks with add, and obtain the final digest with digest or hexdigest. The methods validate that input data is defined and will throw an exception otherwise. This module is a straightforward, MIT-licensed port of Perl's Digest::MD5 for use when you need standard MD5 checksums in SPVM code.

SPVM::Errno provides SPVM programs with a thin, reliable bridge to the system C errno facility so you can read and set the process errno, convert errno values to human messages via strerror, and obtain native error number constants for POSIX and Windows Winsock errors as static methods. Each constant returns the platform's actual numeric code and will raise an Error::NotSupported-style exception if that symbol does not exist on the host, which makes this module handy when calling native APIs or handling low-level I/O and networking errors. Recent releases improved portability and testing, adding MSVC support and a strict cross‑platform test suite that validates 100+ Errno and WSA constants, and a prior bugfix restored constants that could disappear on some environments.

SPVM::Thread is a lightweight SPVM module that exposes native OS threads through a thin wrapper around C++ std::thread, letting SPVM programs run tasks concurrently by creating threads with Thread->new that accept a Callback and return a Thread object. The API is simple: start a task, call join to wait for completion, and use get_id to obtain the thread identifier. It is aimed at SPVM users who need straightforward, native-thread execution without a large concurrency framework.

Google::Ads::GoogleAds::Client is the primary Perl client for talking to the Google Ads API, providing a single place to manage credentials, OAuth handlers, configuration and access to every API service. It reads settings from a googleads.properties file or environment variables, lets you override options like developer token, login or linked customer IDs, proxy, timeouts and API version when creating the client, and exposes a method for each Google Ads service so you can call operations such as searches and mutations. The module also gives programmatic access to OAuth2 application and service-account handlers, records the last HTTP request and response for debugging, and offers a die_on_faults toggle so you can choose between exception-style or explicit error-handling. Note that this client should be loaded before other Google::Ads modules and that it will die if a specified properties file cannot be read.

Map::Tube::Stuttgart is a small Perl module that gives you a ready-made Stuttgart tube map and tools to compute the shortest route between any two stations. It implements the Map::Tube role so you get the familiar route-finding and helper methods from that interface. You construct it with new and may pass an optional xml callback to supply a different map file, otherwise it uses the included stuttgart-map.xml, and its output can be used directly or fed to visualization tools such as Map::Tube::GraphViz. Note that the constructor will die if the map file is missing or corrupted.

Map::Tube::Paris is a small Perl library for finding the shortest route between stations on Paris local and regional transit networks, including metro, RER, Transiliens and tram lines. It implements the Map::Tube role so you construct a Map::Tube::Paris object and call methods such as get_shortest_route to get a route between two stations. By default it loads a bundled paris-map.xml but you can supply your own XML source via a code reference when creating the object. The XML data were taken from Wikipedia and spot-checked against OpenStreetMap and the RATP site. If the map file is missing or corrupted the constructor will die, otherwise this module is a straightforward choice for scripts or services that need basic journey planning or route lookup for Paris transit.

Map::Tube::Muenchen is a small Perl adapter that models Munich's U‑bahn, S‑bahn and tram network and makes it trivial to compute shortest routes between stations using the Map::Tube API. You instantiate the object and call methods such as get_shortest_route with station names, or provide your own XML map source at construction to override the bundled muenchen-map.xml. The module relies on publicly available map data and follows the Map::Tube role so it integrates with the same route-finding and graph utilities, and it will fail fast if the map data are corrupted. Recent maintenance replaced legacy CPAN signing with Sigstore/cosign and updated compatibility with newer Map::Tube releases.

Map::Tube::KoelnBonn provides a simple Perl interface to the Cologne/Bonn U-Bahn, S-Bahn and tram network so you can programmatically find shortest routes between stations in that region. It implements the Map::Tube role and exposes familiar methods such as new() and get_shortest_route, using a bundled XML map by default or an optional code reference you provide to supply alternate XML content. The map data were taken largely from OpenStreetMap under CC BY-SA 2.0 and the module ships a prepared koelnbonn-map.xml; the constructor will die if the map file is corrupted. This is a handy choice for Perl developers building transit tools, route planners, or network visualizations specific to the Cologne/Bonn area. Recent updates include compatibility preparations for Map::Tube v5 and a switch from deprecated cpansign to Sigstore/cosign for code signing, along with improved tests and Unicode handling.

Map::Tube::Beijing is a lightweight Perl module that gives you programmatic access to a bundled Beijing subway map and lets your code compute shortest routes between any two stations using the Map::Tube routing role. It reads an included XML map file and exposes station names either in original Chinese by default or in pinyin when you instantiate it with nametype => 'alt', and it provides the usual Map::Tube methods for finding and formatting routes. The constructor will fail if the map file is corrupted, and the module is intended for developers who want to add Beijing-specific routing or visualization to their Perl apps. Note that a notable change in recent releases is that attribute semantics were flipped so name now contains pinyin and name_alt holds the original Chinese text to match the Map::Tube ecosystem, and the current release was prepared for Map::Tube v5.x and switched package signing to Sigstore/cosign.

Map::Tube::Chicago is a lightweight Perl adapter that lets you compute shortest routes on Chicago’s L and tram network from your code. It implements the Map::Tube role so you get familiar routing methods such as get_shortest_route, and it handles ambiguous station names by appending the line name so duplicate names and interchanges that require walking or checking out and back in are treated distinctly. Construct it with new and optionally provide a code reference to supply an alternate XML map, otherwise it uses the bundled chicago-map.xml. The constructor will die if the map data are corrupted. This module is a good fit if you need simple, scriptable routing for Chicago transit inside Perl applications and it depends on Map::Tube for core behavior; recent updates ensure compatibility with Map::Tube 5.0.1 and replace legacy code signing with Sigstore/cosign.

Tvh::Htsp::Client is a compact Perl library that lets scripts talk to a Tvheadend server using the HTSP protocol, so you can query channel lists, call the server API, receive live replies, and even deserialize HTSP messages or offline EPG databases without a network connection. It offers a simple constructor with sensible defaults for host, port and debug output and convenience routines for sending and receiving HTSP messages plus helpers to look up channel UUIDs, names and IDs by name, id or channel number. The module is useful if you need to automate Tvheadend tasks, dump the EPG to JSON, or build integrations that consume channel and program data. Recent updates improved error checking and test coverage, made debug output and binary blobs easier to read by converting them to hex, and extended the channel lookup to accept channel numbers. Note that the module requires a modern Perl and is intended for developers familiar with Tvheadend or HTSP.

Business::ISBN::Data is a data-only companion to Business::ISBN that supplies the official ISBN registration-group and publisher-range information used to parse, validate, and split ISBNs. You normally do not load it directly because Business::ISBN will load it for you, and the module ships with a copy of the ISBN Agency's RangeMessage.xml so you get authoritative ranges out of the box. If you need newer or alternate data you can point Business::ISBN at another RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable before loading the module, and if no file is available it falls back to built-in data or looks in the current directory to help bundled apps. Note that it requires Business::ISBN 3.005 or later to match the updated data structures addressing ISBN-13 handling. The project is actively updated with frequent data refreshes through June 2026, includes a recent fix to avoid unintended autovivification when reading ISBN_RANGE_MESSAGE, and is maintained on GitHub under the Artistic License 2.0.

Net::Whois::IP is a Perl module for performing WHOIS lookups on IPv4 addresses and returning the results in a program-friendly form. It will follow referrals across registries to gather progressively more detailed information and returns either a parsed hash of normalized fields or the raw WHOIS text, and it can also hand you the full chain of responses when multiple lookups are required. You can request that all duplicate field values be preserved, and the module can synthesize abbreviated ARIN parent/ancestor records into the response when applicable. Live queries require outbound TCP access to WHOIS servers on port 43. This module is useful if you need to automate IP ownership, contact, or allocation lookups from within Perl and want the data returned in a normalized structure, though poking at the low-level search options can break lookup behavior if used incorrectly.

Crypt::OpenSSL::PKCS12 is a Perl interface to OpenSSL’s PKCS#12 functionality that lets you load, inspect, verify and create .p12/.pfx bundles that pair X.509 certificates with private keys. You can construct objects from files or raw strings, extract the certificate, CA chain and private key in Base64 or binary form, verify the PKCS#12 MAC, change passwords, and produce a new PKCS#12 as a file or as a string; there are also convenience methods to dump OpenSSL-style info or a structured hash of the file contents. The module wraps OpenSSL 1.x and 3.x APIs so it works where OpenSSL is installed and requires Perl 5.8 or newer, and it exports a few optional flags for selective processing. Recent releases include important security and memory-safety fixes and correct handling of edge cases such as zero-length attributes and embedded NULs in passwords, so upgrading to the latest version is recommended if you handle untrusted or complex PKCS#12 files.

Template::Sluz is a lightweight Perl templating engine with a Smarty-like syntax that makes it easy to separate presentation from code by letting you write templates with variable substitution, dot-notation, modifiers, default values, conditionals, loops, includes, literal blocks and comments. It has no CPAN dependencies and requires Perl 5.16 or later so you can drop it into small web apps or scripts without extra baggage. Security features include an escape modifier and a new optional auto_escape mode that HTML-encodes untrusted data by default while still allowing a noescape override for trusted content. You can register any Perl function as a modifier and change the single-character template delimiters to avoid conflicts with embedded JavaScript or JSON. Recent updates added the escape and auto-escape options, alternate delimiters, and a substantial performance boost via caching and inlining.

WebService::OPNsense is a Perl client for the OPNsense firewall REST API that makes it easy to script and automate configuration and status queries from Perl. It provides a Moo-based object with lazy accessors for each API controller so you can interact with firewall rules, NAT, IPsec, DHCP, OpenVPN, DNS, captive portal and many other subsystems via simple method calls. Authentication is handled with HTTP Basic Auth using an API key and secret, and the module wraps WebService::Client to normalize requests, URL-encode query parameters, and convert HTTP errors into exceptions while returning undef for missing resources. This release is alpha and welcomes feedback and patches, and users should be aware that OPNsense does not version its API so the client may need updates when the firewall is upgraded. If you want a straightforward Perl interface to manage an OPNsense instance programmatically, this module is a practical starting point.

App::cpm is a fast command line tool for installing Perl modules from CPAN that focuses on reliability and reproducibility. It stages and prepares all dependencies before doing the final install so complex dependency trees and parallel workflows behave more predictably than with a simple one-by-one installer. By default it installs the requested distributions plus their runtime dependency closure, and it provides documentation and a tutorial to get you started quickly. The project also publishes GitHub artifact attestations for released tarballs if you care about provenance. If you want a quicker, more stable alternative to other CPAN installers like cpanminus or tools such as Carton, App::cpm is worth a look.

Map::Tube::London is a lightweight Perl module that models the London Tube network and helps you find the shortest route between stations across the main Underground, DLR and Overground lines, including Bakerloo, Central, Circle, District, Docklands Light Railway, Hammersmith & City, Jubilee, Metropolitan, Northern, London Overground, Piccadilly, Victoria and Waterloo & City. You create a Map::Tube::London object with no configuration and call get_shortest_route(from, to) to receive a Map::Tube::Route object or an exception on error, and if you install the optional Map::Tube::Plugin::Graph plugin you can also get a base64 PNG of a single line or the whole map via as_image. The module is aimed at developers who need simple routing or map output for apps, scripts or demos, and it is open source on GitHub under the Artistic License 2.0.

Map::Tube is a lightweight Perl framework for modeling metro-style transit maps and finding routes between stations. It provides a simple API to load map data (JSON or XML), look up stations and lines, and compute the shortest route by number of stops, with a preference for routes that minimise line changes. The module can also enumerate all possible routes between two stations, though that listing is experimental and can recurse deeply on very large maps. A plugin system adds useful extras such as generating base64 PNG images of maps, formatting nodes and routes as XML/JSON/YAML/text, and fuzzy name searching, and there are companion test modules to validate map data and routing behaviour. The recent v5.0.1 release made the router line-change-aware so ties by hop count are broken in favour of fewer transfers, making suggested journeys more practical for real passengers.