Cybersecurity Services That Keep Your Business Safe

Application Security Services

Catch coding flaws and vulnerabilities before attackers do.

Delivery focus

Built to move from idea to production.

We test and secure your web and mobile applications from the inside out. Our application security services catch coding flaws and vulnerabilities before an attacker finds them first. The work sits inside Cybersecurity Services That Keep Your Business Safe and is scoped, built, reviewed, and handed over as one engagement.

Web application testing

Mobile app testing

Code vulnerability scanning

Security patching

Scope

ClickMasters embeds application security into B2B software for companies across the USA, Europe, Canada, and Australia. Threat modelling that identifies security requirements before design decisions are made. Parameterised queries that prevent SQL injection at the ORM and raw SQL layer. Authentication hardening bcrypt/Argon2 password hashing, JWT best practices, OAuth 2.0 PKCE. Content Security Policy implementation. Rate limiting and input validation. The specific security fixes your audit or pen test identified.

STRIDE Threat Modelling Microsoft's Security Framework

Threat modelling is a structured process for identifying security requirements and potential vulnerabilities during the design phase before code is written. It answers four questions: what are we building (architecture and data flow diagram), what can go wrong (threat enumeration using STRIDE or PASTA methodology), what will we do about it (countermeasures for each identified threat), and did we do a good job (verification that countermeasures are actually implemented). Threat modelling before development is the most cost-effective security activity: a threat identified in design can be addressed by a design decision (which costs nothing to implement) or a few lines of code. The same threat discovered in production requires patching deployed code, testing, re-deploying, and potentially notifying affected customers. Microsoft's research found that fixing a security issue in design costs 1x; fixing it in code costs 6x; fixing it post-deployment costs 100x.

Authentication vs Authorisation The Most Common Security Mistake

Authentication answers "who are you?" it verifies the identity of the user (username/password, OAuth token, certificate). Authorisation answers "what are you allowed to do?" it determines whether the authenticated user has permission to perform a specific action on a specific resource. The most common application security vulnerability is broken authorisation specifically Insecure Direct Object Reference (IDOR): after authentication, a user accesses `/api/orders/1234` (an order that belongs to another user) by simply modifying the ID in the URL. The application verified who the user was (authentication) but failed to verify that the user owns order 1234 (authorisation). Every data-modifying API endpoint must verify both: that the request is authenticated (valid session or token) AND that the authenticated user has permission to perform this action on this specific resource (authorisation check at the resource level, not just the route level). Row-Level Security in PostgreSQL enforces authorisation at the database level a bug in application authorisation logic cannot return another user's data if RLS policies are configured correctly.

What this engagement delivers

Threat Modelling (STRIDE)

Identify security requirements before they become vulnerabilities: STRIDE threat modelling (Spoofing impersonating another user; Tampering modifying data; Repudiation denying an action; Information Disclosure unauthorised data access; Denial of Service making system unavailable; Elevation of Privilege gaining unauthorised access levels), data flow diagramming (DFD map all data flows, identify trust boundaries, highlight where sensitive data crosses trust boundary), threat enumeration (for each trust boundary crossing: what threats are possible? probability and impact?), countermeasure mapping (for each threat: what control mitigates it? is it implemented?). STRIDE conducted as collaborative session with development team building shared security understanding.

Injection Prevention

Prevent injection vulnerabilities: SQL injection (Prisma ORM and parameterised queries user input never concatenated into SQL strings; raw SQL uses positional parameters `db.query('SELECT * FROM users WHERE id = $1', [userId])`), NoSQL injection (MongoDB queries constructed from typed objects, not string interpolation; Zod/Joi validation before DB ops), OS command injection (avoid shell execution functions `exec()`, `system()` with user input; use library APIs instead of shell commands), SSTI (use auto-escaping template engines, never pass user input directly to template evaluation).

Authentication & Session Security

Harden authentication implementation: password hashing (bcrypt with work factor 12+ or Argon2id never MD5, SHA-1, or SHA-256 without salt), brute force protection (rate limiting on login endpoints progressive delays, CAPTCHA after N failures, account lockout with unlock mechanism), secure session management (HttpOnly + Secure + SameSite=Strict cookie attributes, cryptographically random session tokens, session rotation on privilege escalation, invalidation on logout), JWT best practices (RS256 or HS256 with strong secret, short access token TTL 15 minutes, refresh token rotation, no sensitive data in JWT payload JWTs are base64 encoded, not encrypted), MFA implementation (TOTP Time-based One-Time Password RFC 6238, FIDO2/WebAuthn for phishing-resistant MFA).

Content Security Policy (CSP)

XSS mitigation through HTTP response headers: CSP design (strict-dynamic + nonce-based CSP most effective XSS mitigation, avoids unsafe-inline which undermines CSP), nonce generation (per-request random nonce injected into CSP header and all inline scripts prevents attacker-injected scripts from executing), CSP reporting (report-uri or report-to directive collect CSP violation reports to identify both attacks and legitimate scripts blocked), Trusted Types (emerging standard enforces type safety for DOM manipulation prevents DOM XSS by requiring all HTML assignment to use Trusted Type), incremental CSP deployment (use Content-Security-Policy-Report-Only header first to collect violations without blocking tune policy before switching to enforcement).

Security Remediation Engineering

Fix the specific vulnerabilities identified in a security audit or pen test: vulnerability triage (review audit findings with engineering team, clarify reproduction steps, assess fix complexity), fix implementation (ClickMasters engineers implement the fixes not advisory-only), verification (reproduce vulnerability before fixing, confirm not reproducible after fixing), regression prevention (add security test for each fixed vulnerability the test fails if vulnerability is reintroduced), re-test (for pen test findings coordinate re-testing by original provider or conduct application-level re-testing internally). Deliverable: pull requests for all fixes, verified remediation, closing report for each finding.

Process

  1. Phase 1 · 1-2 days

    Threat Modelling Workshop

    STRIDE methodology (Spoofing, Tampering, Repudiation, Info Disclosure, DoS, Elevation of Privilege), data flow diagramming, trust boundary identification, threat enumeration, countermeasure mapping. Deliverable: Threat Model + Mitigation Plan.

  2. Phase 2 · 1-2 weeks

    Injection Prevention Audit

    Review all query patterns (ORM + raw SQL), parameterisation verification, NoSQL injection check, OS command injection audit, SSTI check. Deliverable: Injection Prevention Fixes.

  3. Phase 3 · 2-3 weeks

    Authentication Hardening

    Password hashing upgrade (bcrypt/Argon2), rate limiting on login endpoints, JWT hardening (RS256, short TTL, token rotation), session cookie security (HttpOnly/Secure/SameSite), MFA implementation (TOTP/WebAuthn). Deliverable: Hardened Auth System.

  4. Phase 4 · 1-2 weeks

    CSP Implementation

    Nonce-based CSP design, strict-dynamic policy, report-only phase (collect violations), enforcement deployment, Trusted Types for DOM XSS. Deliverable: CSP Header + Monitoring.

  5. Phase 5 · Per finding

    Security Remediation

    Vulnerability triage, fix implementation, verification (reproduce→confirm not reproducible), regression test addition, re-test coordination. Deliverable: Remediated Findings + Closing Report.

Tech stack

Threat Modelling
STRIDE methodology (Microsoft), PASTA, DFD, OWASP Threat Dragon, draw.io (data flow diagrams)
Injection Prevention
Parameterised queries (ORMs: Prisma/SQLAlchemy/Drizzle; raw SQL: pg, mysql2 with placeholders), Zod/Joi validation
Auth Security
bcrypt (work factor 12+), Argon2id, JWT (RS256/HS256), OAuth 2.0 PKCE, TOTP (RFC 6238), WebAuthn, FIDO2
CSP
Helmet.js (Node.js CSP headers), nginx/apache CSP headers, nonce generation (per-request), Trusted Types, report-uri/logging
Rate Limiting
express-rate-limit (Node.js), with Redis store for distributed deployments, token bucket algorithm

How we work

STRIDE Threat Modelling

Collaborative session with dev team building shared security understanding, not document filed away | Basic: No threat modelling

Microsoft 100x Research Cited

1x design vs 6x code vs 100x post-deploy business case for shifting left | Basic: No cost framing

Argon2id Named

Password hashing: bcrypt work factor 12+ or Argon2id current best practice | Basic: "Secure password hashing" (no specificity)

strict-dynamic + nonce-based CSP

Most effective XSS mitigation eliminates unsafe-inline, per-request nonces | Basic: "CSP implemented" (often unsafe-inline, no protection)

Trusted Types for DOM XSS

Enforces type safety for DOM manipulation prevents DOM XSS at browser level | Basic: No Trusted Types

Where this is used

Security Remediation for Pen Test

12 vulnerabilities from pen test (3 critical, 5 high). Threat modelling for auth system, injection fixes, CSRF protection, rate limiting. All fixed within 4 weeks. Re-test passed.

Authentication Hardening

Password hashing: MD5 → bcrypt work factor 12. JWT: HS256 with weak secret → RS256 with strong key. MFA (TOTP) for admin accounts. Rate limiting on login endpoint.

CSP for XSS Prevention

strict-dynamic + nonce-based CSP deployed. Report-only phase for 2 weeks (0 violations not from test). Enforcement deployed. DOM XSS prevented.

Secure Payment Flow

Threat modelling for payment flow. Session security for checkout, CSRF protection, rate limiting on payment endpoint. PCI DSS compliance achieved.

Pricing guidance

These ranges are planning anchors. The quote names scope, timeline, and what is excluded. Talk through a quote.

Threat Modelling Workshop

$4,000 - $8,000

1 - 2 days

STRIDE, DFD, threat enumeration, countermeasure mapping, findings report

Injection Prevention Audit + Fix

$3,000 - $8,000

1 - 2 weeks

All query patterns audited, parameterisation implemented, test coverage

Authentication Security Hardening

$4,000 - $10,000

2 - 3 weeks

Password hashing, session security, JWT hardening, MFA implementation

CSP Implementation

$3,000 - $8,000

1 - 2 weeks

Nonce-based CSP, report-only phase, enforcement, violation monitoring

Rate Limiting & Input Validation

$3,000 - $8,000

1 - 2 weeks

Per-endpoint rate limits, Zod/Joi validation, file upload security

Security Remediation (per finding)

$1,500 - $4,000

3 - 5 days

Fix implementation, verification, regression test, closing report

Full AppSec Engagement

$10,000 - $28,000

3 - 6 weeks

Threat model + all OWASP controls + remediation + test coverage

AppSec Retainer

$2,500 - $6,000/mo

Ongoing

Code review, new feature security, dependency patches, pen test prep

FAQs

What is threat modelling and why should it happen before development?

Threat modelling is a structured process for identifying security requirements and potential vulnerabilities during the design phase before code is written. It answers four questions: what are we building (architecture and data flow diagram), what can go wrong (threat enumeration using STRIDE or PASTA methodology), what will we do about it (countermeasures for each identified threat), and did we do a good job (verification that countermeasures are actually implemented). Threat modelling before development is the most cost-effective security activity: a threat identified in design can be addressed by a design decision (which costs nothing to implement) or a few lines of code. The same threat discovered in production requires patching deployed code, testing, re-deploying, and potentially notifying affected customers. Microsoft's research found that fixing a security issue in design costs 1x; fixing it in code costs 6x; fixing it post-deployment costs 100x.

How do you prevent SQL injection?

SQL injection prevention is achieved through parameterised queries also called prepared statements. Instead of building an SQL string by concatenating user input (`SELECT * FROM users WHERE email = '' + userInput + ''`), a parameterised query uses a placeholder (`SELECT * FROM users WHERE email = $1`) and passes the user input as a separate parameter. The database driver handles the separation user input is never interpreted as SQL syntax, regardless of what it contains. ORMs (Prisma, Drizzle, SQLAlchemy) use parameterised queries by default for all standard operations SQL injection through ORM-generated queries is extremely rare. The risk surfaces in raw SQL queries (when developers write `db.query('SELECT * FROM ' + tableName)` never construct SQL from user input even for table names or column names use a whitelist instead), in stored procedures (parameter handling within stored procedures must also use parameterised queries), and in ORM escape functions (some developers use ORM escape functions and string interpolation less safe than parameterised queries, which should be the default).

What is Content Security Policy (CSP) and how does it prevent XSS?

Content Security Policy (CSP) is an HTTP response header that tells the browser which resources it is allowed to load for a given page preventing the browser from loading or executing resources from untrusted sources. CSP prevents Cross-Site Scripting (XSS) by: blocking inline scripts unless they carry a server-provided nonce (`<script nonce='abc123'>` matched against CSP header's `nonce-abc123` directive a random nonce generated per request that an attacker cannot predict), blocking scripts from external domains not explicitly in the policy, and (with Trusted Types) preventing DOM manipulation without type-safe wrappers. A correctly implemented nonce-based CSP eliminates most XSS exploitation even when XSS injection points exist the attacker can inject HTML but cannot execute JavaScript because their injected script lacks the valid nonce. CSP is one of the most impactful single security controls available for web applications. Implementation note: many organisations deploy an overly permissive CSP (`unsafe-inline` or `*` wildcards) that provides no protection a strict nonce-based CSP is more complex to implement but actually prevents attacks.

What is the difference between authentication and authorisation?

Authentication answers "who are you?" it verifies the identity of the user (username/password, OAuth token, certificate). Authorisation answers "what are you allowed to do?" it determines whether the authenticated user has permission to perform a specific action on a specific resource. The most common application security vulnerability is broken authorisation specifically Insecure Direct Object Reference (IDOR): after authentication, a user accesses `/api/orders/1234` (an order that belongs to another user) by simply modifying the ID in the URL. The application verified who the user was (authentication) but failed to verify that the user owns order 1234 (authorisation). Every data-modifying API endpoint must verify both: that the request is authenticated (valid session or token) AND that the authenticated user has permission to perform this action on this specific resource (authorisation check at the resource level, not just the route level). Row-Level Security in PostgreSQL enforces authorisation at the database level a bug in application authorisation logic cannot return another user's data if RLS policies are configured correctly.

Related reading

Application Security Services is one line inside Cybersecurity Services That Keep Your Business Safe. Teams with an adjacent problem often compare it with Cybersecurity Risk Assessment Services and Penetration Testing. For a written delivery narrative, read the SaaS booking platform QA case study and the rest of the case studies.