Sentryline: Web Security Posture
Defensive analysis of data you supply: security headers graded with reasoning, TLS certificates parsed by a DER parser written from the specification, and npm audit reports rolled up to the dependency you actually have to upgrade. It scans nothing.
This is a working demonstration, not a client engagement. The brand and data are fictional.

Background
Security tooling is the area where a demo is most tempting to fake, because the output looks authoritative whether or not anything was checked. This one is built so that every claim can be traced to data the user supplied and logic that is tested.
The challenge
A browser cannot read another origin's response headers, and cannot inspect a TLS certificate at all. Any page claiming to scan a site from the browser is proxying through a server it has not mentioned. The honest design has to make the input the user's own, and say why.
Objectives
- Analyse only data the user supplies, and say why that constraint is technical as well as ethical.
- Implement the parsing so the output can be checked against an independent tool.
- Attach reasoning to every finding rather than emitting a bare score.
My role
Sole designer and developer
- Wrote the DER/ASN.1 parser and X.509 reader: subject, issuer, validity, key algorithm and size, signature algorithm, subjectAltName and basic constraints
- Verified the parser against openssl: the test suite asserts the subject, validity window and SAN list match `openssl x509` for eight generated certificates
- Built the header rule engine: CSP parsed directive by directive, HSTS, cookies, X-Frame-Options conflicts, wildcard CORS and version disclosure
- Implemented browser wildcard host matching, so *.example.com does not match a.b.example.com or the bare domain
- Built the npm audit reader, walking the effects chain to the direct dependency responsible
- Wrote 57 unit tests and 23 browser checks
Technical approach
Analyse only what is pasted in: a response head from curl, a PEM certificate from openssl, an audit report from npm. State the scope in the interface, in the footer and in the README. Implement the parsing rather than importing it, so the analysis can be verified against an independent tool.
What is implemented
- Security header grading with CSP parsed directive by directive
- HSTS, cookie, CORS and version-disclosure checks with severity and explanation
- X.509 parsing from a DER/ASN.1 parser: subject, issuer, validity, key size, signature, SANs
- Browser wildcard host matching, so *.example.com does not match a.b.example.com
- npm audit report rollup that walks the effects chain to the direct dependency to upgrade
- A watchlist that tracks a grade over results the user has recorded
Process
- Wrote the ASN.1/DER parser and the X.509 reader.
- Generated eight test certificates with openssl and Python's cryptography library: valid, wildcard, 1024-bit, SHA-1, ECDSA, over-long lifetime, no SAN and genuinely expired.
- Wrote tests that compare the parser's output against `openssl x509` for every one of them.
- Built the header rule engine, with the reasoning attached to each finding rather than a bare score.
- Built the npm audit reader and the watchlist, which records results the user has run so a grade can be tracked over time.
Engineering and creative decisions
Nothing is fetched, and the interface says why
A browser cannot read another origin's response headers or inspect a certificate. A page claiming to scan a site from the browser is proxying through a server it has not mentioned. The input is the user's own.
The parser is checked against openssl
Eight generated certificates are parsed and compared against what openssl x509 reports for the same files. If the ASN.1 parser drifts, openssl disagrees and the suite fails.
Penalties have diminishing returns
The first scoring model summed a penalty per finding, which graded a response with no security headers above one with eight configured badly. The second gave the analyser more to find. Sorting penalties worst-first and decaying them fixed the ordering, and a test now asserts it.
Limits are stated in the interface
It cannot verify a signature chain, reach a root store or check revocation. Those need a TLS client, and the certificate panel says so above the result.
What was delivered
Four views (watchlist, headers, certificate, dependencies) over data the user provides, with every limitation stated where someone would otherwise assume otherwise.
Results
- 57 unit tests and 23 browser checks pass. The certificate tests fail if the parser ever disagrees with openssl.
- The first scoring model was wrong, and testing showed it: summing a penalty per finding graded a response with no security headers above one with eight headers configured badly, because the second gave the analyser more to find. Replaced with diminishing returns, and a test now asserts the ordering.
- The interface states what it cannot do (verify a signature chain, reach a root store, check revocation) rather than leaving the impression that it did.
- No node-forge, pkijs or header-scanner library: the ASN.1 parser, CSP parser and rule engine are in the source.
These are tested capabilities of the demonstration, not commercial outcomes.
Technology stack
Visual demonstration
Captured from the running application.






