meteor-security
/meteor-security
Audytuje i utwardza aplikację Meteor 3: check() w argumentach metod, kontrola this.userId w publikacjach, CSP z browser-policy, reguły DDPRateLimiter, oauth-encryption i audit-argument-checks.
- Autor
- meteor ↗
- Repozytorium
- agent-skills ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 23.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 4
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 23.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Audytuje i utwardza aplikację Meteor 3: check() w argumentach metod, kontrola this.userId w publikacjach, CSP z browser-policy, reguły DDPRateLimiter, oauth-encryption i audit-argument-checks.
Oryginalny opis (EN)
Use when auditing or hardening a Meteor 3 application. Triggers on missing check() on method arguments, missing this.userId guards on publications, browser-policy CSP, DDPRateLimiter rules, oauth-encryption via Accounts.config oauthSecretKey, audit-argument-checks, allow/deny legacy patterns, BrowserPolicy.content.disallowInlineScripts, BrowserPolicy.framing.disallow. Use this skill when the user asks about hardening, asks about a security review, or asks about CSP for a third-party script (Stripe, Google Maps, fonts).
Jak działa
- Decision flow
- Accounts collection and profile policy
- Method guard checklist
- Publication guard checklist
- CSP via browser-policy
- DDPRateLimiter for sensitive methods
- OAuth secret encryption
- audit-argument-checks
- Anti-patterns
- See also
Podgląd SKILL.md
---
name: meteor-security
description: >
Use when auditing or hardening a Meteor 3 application. Triggers on
missing check() on method arguments, missing this.userId guards on
publications, browser-policy CSP, DDPRateLimiter rules, oauth-encryption
via Accounts.config oauthSecretKey, audit-argument-checks, allow/deny
legacy patterns, BrowserPolicy.content.disallowInlineScripts,
BrowserPolicy.framing.disallow. Use this skill when the user asks about
hardening, asks about a security review, or asks about CSP for a
third-party script (Stripe, Google Maps, fonts).
metadata:
author: meteor
kind: knowledge
meteor: ">=3.0"
area: security
tagline: "Audit and harden Meteor 3 apps (`check()` coverage, `this.userId` guards, browser-policy CSP, rate limits, oauth-encryption)."
bundle: ["essentials", "fullstack"]
docs_synced_at: "2026-10-07"
license: MIT
---
# Meteor security
Meteor's security model is opinionated: the server holds authority, the
client cannot be trusted, and the only places that filter data before it
reaches users are methods (write paths) and publications (read paths).
## Decision flow
1. Audit every method: does it `check()` every argument and guard on
`this.userId` or `Meteor.userId()` when authentication matters?
2. Audit every publication: does it filter by `this.userId` (when
user-specific) and project columns with `fields`?
3. Add `audit-argument-checks` in dev to catch missing `check()`.
4. Add `browser-policy` and configure CSP.
5. Add `DDPRateLimiter` rules for sensitive methods (login, password
reset, resource creation).
6. If the app uses OAuth, set `oauthSecretKey` to encrypt provider
secrets at rest.
7. Replace permissive client-write rules with authenticated methods. Keep
protective `deny` rules until an equivalent method-only policy is active;
Accounts can add an owner-only `profile` allowance even without an app
`allow` rule. See the profile policy below.
## Accounts collection and profile policy
In Meteor 3.6's fixed Accounts pairing, custom users collections receive account
indexes and, when client mutation methods exist, the default owner-only profile
allowance. Configure the collection on both runtimes before installing guards.
Keep `Meteor.users.deny({ update: () => true })` on the selected collection when
all client profile writes must be blocked, until an equivalent policy is proven.
`defineMutationMethods: false` supplies a method-only collection without those
validators; the RC still creates account indexes. Earlier packages require
checking their setup behavior. See `meteor-accounts` for collection identity,
secondary Accounts instances and package boundaries. Never trust roles stored
in a client-editable profile.
## Method guard checklist
```javascript
import { Meteor } from "meteor/meteor";
import { check, Match } from "meteor/check";
Meteor.methods({
async updateProfile(payload) {
check(payload, { displayName: String, bio: Match.Optional(String) });
if (!this.userId) {
throw new Meteor.Error("not-authorized");
}
await Meteor.users.updateAsync(this.userId, { $set: { profile: payload } });
},
async updateAddress(payload) {
check(payload, String);
if (!Meteor.userId()) {
throw new Meteor.Error("not-authorized");
}
await Meteor.users.updateAsync(Meteor.userId(), { $set: { address: payload } });
},
});
```
Reject any method that does not match: `check` on every argument, userId
gate when needed, `Meteor.Error(code, reason)` for failures, `*Async`
Mongo on the server.
## Publication guard checklist
```javascript
Meteor.publish("items.mine", function () {
if (!this.userId) return this.ready();
return Items.find(
{ ownerId: this.userId },
{ fields: { title: 1, qty: 1 }, limit: 200 },
);
});
```
Reject any publication that returns an unbounded cursor, omits the field
projection, or skips a userId filter on user-specific data.
## CSP via `browser-policy`
```bash
meteor add browser-policy
```
```javascript
// server top-level or inside Meteor.startup
import { BrowserPolicy } from "meteor/browser-policy-common";
import { Meteor } from "meteor/meteor";
Meteor.startup(async () => {
await BrowserPolicy.content.disallowInlineScripts();
BrowserPolicy.content.disallowEval();
BrowserPolicy.framing.disallow();
});
```
`BrowserPolicy` is server-only. Configure it during module initialization or
startup so every request receives one deterministic process-wide policy. The
current implementation invalidates its cached CSP after a mutation, but do not
mutate this global policy per request or per user. See
`references/browser-policy-csp.md` for recipes (Stripe, Google Maps,
fonts, inline-style allowance).
## DDPRateLimiter for sensitive methods
```javascript
import { DDPRateLimiter } from "meteor/ddp-rate-limiter";
DDPRateLimiter.addRule(
{
type: "method",
name: "login",
clientAddress: () => true,
},
5,
60000, // 5 attempts per 60s, per IP
);
```
Only matcher fields contribute to the rate-limit bucket key. Without
`clientAddress`, `connectionId`, or `userId`, every matching caller shares one
global bucket. Meteor 3.5+ permits async matcher functions for database-backed
decisions; keep their queries fast because the connection waits for them. On
Meteor 3.0 through 3.4, matchers must stay synchronous. Use a fixed rule,
precomputed synchronous state, or upgrade rather than awaiting Mongo there.
The default rule (5 in 10s per matched method per DDP connection for login / signup / password
reset) ships with `accounts-base`. Meteor 3.6-beta.1's
`accounts-base@3.4.0-beta360.1` also matches `requestLoginTokenForUser`;
`accounts-passwordless@3.1.2-beta360.1` validates its complete payload before
lookup/creation. The RC pairing is `accounts-base@3.4.0-rc360.0` with
`accounts-passwordless@3.1.2-rc360.0`; handle callback rate errors without
an immediate retry loop. Inspect both package versions on older apps. Remove the
default rule with `Accounts.removeDefaultRateLimit()` only if you replace it.
For cookie hardening on `accounts-base@3.4.0-beta360.1`, use `meteor-accounts`:
trusted origins, valid tokens, no-store responses and `SameSite=Strict` have
specific migration checks. Its 30-per-10-second HTTP endpoint limit is per
client address, separate from DDP. HttpOnly storage does not stop active
same-origin XSS from obtaining the resume token used for DDP authentication.
## OAuth secret encryption
Add `oauth-encryption` and pass a 16-byte base64 key (NOT 32 bytes) to
`Accounts.config` at module top level (not inside `Meteor.startup`):
```bash
meteor node -e "console.log(require('crypto').randomBytes(16).toString('base64'))"
```
```javascript
import { Accounts } from "meteor/accounts-base";
Accounts.config({
oauthSecretKey: Meteor.settings.oauthSecretKey,
});
```
At startup, `accounts-oauth` seals an unsealed provider application secret at
`ServiceConfiguration.configurations.secret`. Provider packages also seal
supported per-user token fields, such as `services.github.accessToken` or
Twitter's `accessTokenSecret`. There is no generic
`Meteor.users.services.<provider>.secret` field. Inspect the provider schema
before asserting which user credential is encrypted.
## `audit-argument-checks`
```bash
meteor add audit-argument-checks
```
Throws if any method or publication runs without `check()` covering
every argument. Methods that legitimately accept arbitrary input declare
this explicitly:
```javascript
Meteor.methods({
rawLog(...args) {
check(args, [Match.Any]);
// ...
},
});
```
## Anti-patterns
- Permissive client-write rules for sensitive data. Replace with guarded
methods; do not remove protective denial before proving equivalent policy.
- `Meteor.settings.public.<secret>`. The client sees `public`. Move
secrets to the top level of `settings.json`.
- Publish the entire `Meteor.users` collection. Always project (e.g.
`fields: { username: 1, profile: 1 }`) and filter. Publish email only to
the owning user or another explicitly authorized audience.
- Use `BrowserPolicy.content.allowOriginForAll` for a third-party script. It
grants the origin to every current content directive. Allow only the script,
frame, connect, image, style, or font directives the integration needs.
- Methods that accept callback-shaped arguments. Functions cannot travel
over DDP.
- Call `Accounts.config({ oauthSecretKey })` inside `Meteor.startup`.
Must be at module top level so it loads before the OAuth packages
read it.
## See also
- `references/method-and-publish-guards.md`
- `references/browser-policy-csp.md`
- `references/eval-cases.md`
- Related skills: `meteor-methods`, `meteor-pubsub`, `meteor-accounts`.
Pliki w paczce (4)
- SKILL.md 9 KB
- references/browser-policy-csp.md 3 KB
- references/eval-cases.md 5 KB
- references/method-and-publish-guards.md 2 KB
Wersje
W bazie nie ma innych skilli o nazwie meteor-security.
Migawka bazy z 13.11.2026 · wersja paczki a6a2b45b7459 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100meteor-methods
Pomaga pisać i debugować metody Meteor (Meteor.methods, Meteor.call): walidacja argumentów przez check(), optymistyczne stuby, kompensacja opóźnień, Meteor.Error i DDPRateLimiter. - 100hardening-llm-agent-apps
Utwardza istniejące aplikacje webowe z LLM lub agentem: przegląd OWASP LLM, iniekcje promptów, polityka narzędzi, CSP i testy poprawek. - 100meteor-accounts
Konfiguruje uwierzytelnianie w aplikacji Meteor 3: accounts-password, OAuth (Google, Facebook, GitHub, Apple i inne), 2FA, logowanie bez hasła, reset hasła i weryfikację e-mail. - 100security
Ustala reguły bezpieczeństwa dla projektów odizolowanych od sieci: Content Security Policy, nagłówki i brak inline skryptów. - 95memstack-security-csp-headers
Audytuje i generuje nagłówki bezpieczeństwa HTTP, w tym Content-Security-Policy, HSTS i ochronę ramek. - 100bc-security
Wdraża bezpieczeństwo integracji BigCommerce: zarządzanie tokenami OAuth, uwierzytelnianie API, weryfikacja webhooków, CSP, walidacja danych wejściowych i zgodność z PCI.