@blamejs/blamejs-shop 0.0.44

package/lib/vendor/blamejs/lib/mail-spam-score.js

@@ -0,0 +1,284 @@
+"use strict";
+/**
+ * @module     b.mail.spamScore
+ * @nav        Mail
+ * @title      Mail Spam Score
+ * @order      557
+ *
+ * @intro
+ *   Operator-supplied spam scorer facade. The framework deliberately
+ *   does NOT vendor a spam-classifier engine — the bayes corpora,
+ *   URIBL caches, neural models, and per-recipient training are all
+ *   operator state. Instead, `b.mail.spamScore.create` wraps the
+ *   operator's chosen scorer (SpamAssassin via spamc, Rspamd HTTP
+ *   API, Cloudmark, Vade, in-house) in a uniform threshold-driven
+ *   verdict pipeline that the MX listener (v0.9.45) and submission
+ *   listener (v0.9.47) consume.
+ *
+ *   ## Operator-supplied scorer contract
+ *
+ *   ```
+ *   async function scorer({ rawBytes, headers, envelope }) {
+ *     // call out to SpamAssassin / Rspamd / commercial scorer
+ *     return { score: 7.3, reasons: ["BAYES_99", "URIBL_RED"] };
+ *   }
+ *   ```
+ *
+ *   - `score` MUST be a finite number (any range; the threshold is
+ *     operator-tuned). Negative scores mean "ham-shaped"; positive
+ *     scores mean "spam-shaped". Convention matches SpamAssassin.
+ *   - `reasons` MUST be an Array of short ASCII tags. The facade caps
+ *     each tag at 256 bytes and refuses control bytes; the cap protects
+ *     audit storage + outbound headers (`X-Spam-Status: ...`) from
+ *     hostile expansion via a compromised scorer.
+ *
+ *   ## Thresholds
+ *
+ *   - **strict** — 5.0 (matches SpamAssassin's default `required_score`).
+ *   - **balanced** — 7.5.
+ *   - **permissive** — 10.0.
+ *
+ *   Operators tune via `opts.threshold` per-instance. The verdict is
+ *   `"accept"` (score < threshold), `"score-tag"` (score === threshold —
+ *   add `X-Spam-Status` header but deliver), or `"refuse"`
+ *   (score > threshold — return SMTP 550).
+ *
+ *   ## Composition
+ *
+ *   - **`b.audit`** receives every `score` / `accept` / `score_tag` /
+ *     `refuse` decision. Audit failure is drop-silent (hot path).
+ *
+ *   ## Threat model
+ *
+ *   - **Hostile reason-tag** (compromised scorer injects CRLF into a
+ *     tag, smuggling extra `X-Spam-*` headers into the outbound
+ *     wrapper): defended by per-tag length cap + control-byte refusal.
+ *   - **NaN / Infinity score** (scorer bug): refused as
+ *     `mail-spam-score/bad-score`; the listener treats the message as
+ *     unscanned (operator's tempfail policy applies).
+ *   - **Slow scorer DoS**: the scorer function is operator code, so
+ *     timing belongs to the operator. The listener wraps the
+ *     `.score()` promise in its own per-connection deadline.
+ *
+ * @card
+ *   Threshold-driven spam-scorer facade. Operator wires SpamAssassin /
+ *   Rspamd / commercial scorer; the framework owns the verdict
+ *   pipeline + reason-tag hardening + audit emission. Three default
+ *   thresholds (strict 5.0 / balanced 7.5 / permissive 10.0).
+ */
+
+var { defineClass }   = require("./framework-error");
+var lazyRequire       = require("./lazy-require");
+var validateOpts      = require("./validate-opts");
+
+var audit = lazyRequire(function () { return require("./audit"); });
+
+var MailSpamScoreError = defineClass("MailSpamScoreError", { alwaysPermanent: true });
+
+var DEFAULT_PROFILE = "strict";
+
+// allow:raw-byte-literal — reason-tag length cap defends outbound
+// header / audit-store from hostile expansion via compromised scorer.
+var MAX_REASON_BYTES = 256;
+
+// allow:raw-byte-literal — reason-list count cap, defends audit volume.
+var MAX_REASONS = 32;
+
+var PROFILES = Object.freeze({
+  strict:     { threshold: 5.0,  maxReasons: MAX_REASONS, maxReasonBytes: MAX_REASON_BYTES },      // allow:raw-byte-literal — matches SpamAssassin default required_score
+  balanced:   { threshold: 7.5,  maxReasons: MAX_REASONS, maxReasonBytes: MAX_REASON_BYTES },
+  permissive: { threshold: 10.0, maxReasons: MAX_REASONS, maxReasonBytes: MAX_REASON_BYTES },
+});
+
+var COMPLIANCE_POSTURES = Object.freeze({
+  hipaa:     "strict",
+  "pci-dss": "strict",
+  gdpr:      "strict",
+  soc2:      "strict",
+});
+
+/**
+ * @primitive b.mail.spamScore.create
+ * @signature b.mail.spamScore.create(opts)
+ * @since     0.9.81
+ * @status    stable
+ * @related   b.mail.scan.create
+ *
+ * Build a spam-score handle. Returns `{ score(message, opts),
+ * threshold, profile, MailSpamScoreError }` where `.score` resolves to
+ * `{ score, reasons, verdict }`. `verdict` is `"accept"` /
+ * `"score-tag"` / `"refuse"` based on threshold comparison.
+ *
+ * @opts
+ *   scorer:    async fn({ rawBytes, headers, envelope }) → { score, reasons } — required
+ *   threshold: number — overrides profile default
+ *   profile:   "strict" | "balanced" | "permissive"
+ *   posture:   "hipaa" | "pci-dss" | "gdpr" | "soc2"
+ *   audit:     b.audit instance
+ *
+ * @example
+ *   var spam = b.mail.spamScore.create({
+ *     scorer: async function (ctx) {
+ *       return await callSpamAssassin(ctx.rawBytes);
+ *     },
+ *   });
+ *   var v = await spam.score({ rawBytes: msg });
+ *   if (v.verdict === "refuse") refuseConnection(v.reasons.join(","));
+ */
+function create(opts) {
+  opts = validateOpts.requireObject(opts || {}, "mail.spamScore.create",
+    MailSpamScoreError, "mail-spam-score/bad-opts");
+  validateOpts(opts, [
+    "scorer", "threshold", "profile", "posture", "audit",
+  ], "mail.spamScore.create");
+  if (typeof opts.scorer !== "function") {
+    throw new MailSpamScoreError("mail-spam-score/bad-scorer",
+      "mail.spamScore.create.scorer must be a function; got " + (typeof opts.scorer));
+  }
+  var profile = opts.profile || (opts.posture && COMPLIANCE_POSTURES[opts.posture]) || DEFAULT_PROFILE;
+  if (!PROFILES[profile]) {
+    throw new MailSpamScoreError("mail-spam-score/bad-profile",
+      "mail.spamScore.create.profile: unknown '" + profile +
+      "' (valid: strict / balanced / permissive)");
+  }
+  var caps = PROFILES[profile];
+  var threshold;
+  if (opts.threshold !== undefined) {
+    if (typeof opts.threshold !== "number" || !isFinite(opts.threshold)) {
+      throw new MailSpamScoreError("mail-spam-score/bad-threshold",
+        "mail.spamScore.create.threshold must be a finite number; got " +
+        (typeof opts.threshold) + " " + String(opts.threshold));
+    }
+    threshold = opts.threshold;
+  } else {
+    threshold = caps.threshold;
+  }
+  var auditImpl = opts.audit || audit();
+
+  async function score(message) {
+    if (!message || typeof message !== "object") {
+      throw new MailSpamScoreError("mail-spam-score/bad-input",
+        "mail.spamScore.score: message must be an object with rawBytes/headers/envelope");
+    }
+    var rv;
+    try {
+      rv = await opts.scorer({
+        rawBytes: message.rawBytes,
+        headers:  message.headers || {},
+        envelope: message.envelope || {},
+      });
+    } catch (e) {
+      _emitAudit(auditImpl, "mail.spam_score.error", "failure", {
+        message: (e && e.message) || String(e),
+      });
+      throw new MailSpamScoreError("mail-spam-score/scorer-threw",
+        "mail.spamScore.score: scorer threw: " + ((e && e.message) || e));
+    }
+    if (!rv || typeof rv !== "object") {
+      throw new MailSpamScoreError("mail-spam-score/bad-result",
+        "mail.spamScore.score: scorer must return { score, reasons }; got " +
+        (typeof rv));
+    }
+    if (typeof rv.score !== "number" || !isFinite(rv.score)) {
+      throw new MailSpamScoreError("mail-spam-score/bad-score",
+        "mail.spamScore.score: scorer returned non-finite score=" + String(rv.score));
+    }
+    var reasons = _sanitizeReasons(rv.reasons, caps);
+
+    var verdict;
+    if (rv.score < threshold)       verdict = "accept";
+    else if (rv.score === threshold) verdict = "score-tag";
+    else                              verdict = "refuse";
+
+    _emitAudit(auditImpl, "mail.spam_score.score", "success", {
+      score: rv.score, threshold: threshold, verdict: verdict, reasons: reasons,
+    });
+    if (verdict === "accept") {
+      _emitAudit(auditImpl, "mail.spam_score.accept", "success", { score: rv.score });
+    } else if (verdict === "score-tag") {
+      _emitAudit(auditImpl, "mail.spam_score.score_tag", "success",
+        { score: rv.score, reasons: reasons });
+    } else {
+      _emitAudit(auditImpl, "mail.spam_score.refuse", "success",
+        { score: rv.score, reasons: reasons });
+    }
+    return { score: rv.score, reasons: reasons, verdict: verdict };
+  }
+
+  return {
+    score:                score,
+    threshold:            threshold,
+    profile:              profile,
+    MailSpamScoreError:   MailSpamScoreError,
+  };
+}
+
+/**
+ * @primitive b.mail.spamScore.compliancePosture
+ * @signature b.mail.spamScore.compliancePosture(posture)
+ * @since     0.9.81
+ * @status    stable
+ *
+ * Return the effective profile name for a compliance posture, or
+ * `null` for unknown posture names.
+ *
+ * @example
+ *   b.mail.spamScore.compliancePosture("hipaa");   // → "strict"
+ */
+function compliancePosture(posture) {
+  return COMPLIANCE_POSTURES[posture] || null;
+}
+
+function _sanitizeReasons(reasons, caps) {
+  if (reasons === undefined || reasons === null) return [];
+  if (!Array.isArray(reasons)) {
+    throw new MailSpamScoreError("mail-spam-score/bad-reasons",
+      "mail.spamScore.score: scorer returned non-array reasons (" + (typeof reasons) + ")");
+  }
+  if (reasons.length > caps.maxReasons) {
+    throw new MailSpamScoreError("mail-spam-score/too-many-reasons",
+      "mail.spamScore.score: scorer returned " + reasons.length +
+      " reasons; cap is " + caps.maxReasons);
+  }
+  var out = [];
+  for (var i = 0; i < reasons.length; i += 1) {
+    var r = reasons[i];
+    if (typeof r !== "string" || r.length === 0) {
+      throw new MailSpamScoreError("mail-spam-score/bad-reason",
+        "mail.spamScore.score: reasons[" + i + "] must be a non-empty string");
+    }
+    if (Buffer.byteLength(r, "utf8") > caps.maxReasonBytes) {
+      throw new MailSpamScoreError("mail-spam-score/oversize-reason",
+        "mail.spamScore.score: reasons[" + i + "] exceeds " + caps.maxReasonBytes + " bytes");
+    }
+    // Refuse control bytes (CR / LF / NUL / etc.) — a compromised
+    // scorer could try to smuggle CRLF into an outbound X-Spam-Status
+    // header.
+    for (var c = 0; c < r.length; c += 1) {
+      var cc = r.charCodeAt(c);
+      if (cc < 0x20 || cc === 0x7f) {                                                              // allow:raw-byte-literal — RFC 5234 CTL refusal range
+        throw new MailSpamScoreError("mail-spam-score/control-byte",
+          "mail.spamScore.score: reasons[" + i + "] contains control byte 0x" +
+          cc.toString(16));                                                                        // allow:raw-byte-literal — hex radix
+      }
+    }
+    out.push(r);
+  }
+  return out;
+}
+
+function _emitAudit(auditImpl, action, outcome, metadata) {
+  try {
+    if (auditImpl && typeof auditImpl.safeEmit === "function") {
+      auditImpl.safeEmit({ action: action, outcome: outcome, metadata: metadata });
+    }
+  } catch (_e) { /* drop-silent — audit failures don't break score path */ }
+}
+
+module.exports = {
+  create:                create,
+  compliancePosture:     compliancePosture,
+  PROFILES:              PROFILES,
+  COMPLIANCE_POSTURES:   COMPLIANCE_POSTURES,
+  MailSpamScoreError:    MailSpamScoreError,
+};

package/lib/vendor/blamejs/lib/mail-srs.js

@@ -0,0 +1,248 @@
+"use strict";
+/**
+ * @module     b.mail.srs
+ * @nav        Mail
+ * @title      SRS — Sender Rewriting Scheme
+ * @order      450
+ *
+ * @intro
+ *   Sender Rewriting Scheme (SRS0 / SRS1) — when a forwarder
+ *   retransmits a message it received, SPF on the next hop will
+ *   typically fail because the envelope-from sender is the original
+ *   sender's domain, but the message is now coming from the
+ *   forwarder's IP. SRS rewrites the envelope-from local-part to
+ *   encode the original sender + a HMAC signature; the receiver
+ *   verifies + reverses to deliver bounces correctly.
+ *
+ *   Wire format (SRS0):
+ *
+ *     SRS0=HHH=TT=domain=local@forwarder.example
+ *
+ *   Where:
+ *     - `HHH` is the first 4 chars of base32(HMAC-SHA-256(secret,
+ *       lowercase(TT=domain=local))) — short-tag binding the rewrite
+ *       to the operator's signing secret
+ *     - `TT` is a 2-character base32 day-of-time stamp (mod-1024
+ *       day rotation; rejects rewrites older than ~30 days)
+ *     - `domain` is the original sender's domain
+ *     - `local` is the original sender's local-part
+ *     - `forwarder.example` is the rewriting forwarder's domain
+ *
+ *   SRS1 (double-forward case): when an already-SRS0-encoded address
+ *   gets forwarded a second time, SRS1 wraps the SRS0 envelope
+ *   instead of re-encoding from scratch, preserving the original
+ *   sender chain.
+ *
+ *   `b.mail.srs.create({ secret, forwarderDomain })` returns
+ *   `{ rewrite, reverse }`. `rewrite(originalSender)` produces the
+ *   SRS-encoded address; `reverse(srsAddress)` decodes back to the
+ *   original sender + verifies the HMAC.
+ *
+ * @card
+ *   SRS Sender Rewriting Scheme — forwarder envelope-from rewriting with HMAC-bound day-rotated tags so the next-hop SPF check passes and bounces route correctly back to the original sender.
+ */
+
+var nodeCrypto    = require("node:crypto");
+var bCrypto = require("./crypto");
+var validateOpts  = require("./validate-opts");
+var { defineClass } = require("./framework-error");
+
+var SrsError = defineClass("SrsError", { alwaysPermanent: true });
+
+// SRS spec: 2-char base32 day stamp. The rotation cycle is 1024 days
+// (32 * 32) which is ~2.8 years; valid-window is the operator-supplied
+// expiry (default 30 days).
+var BASE32 = "abcdefghijklmnopqrstuvwxyz234567";
+
+function _base32Encode(buf) {
+  var out = "";
+  var bits = 0;
+  var value = 0;
+  for (var i = 0; i < buf.length; i += 1) {
+    value = (value << 8) | buf[i];                                                                 // allow:raw-byte-literal — byte-aligned shift
+    bits += 8;                                                                                     // allow:raw-byte-literal — bits-per-byte constant
+    while (bits >= 5) {
+      out += BASE32.charAt((value >>> (bits - 5)) & 31);
+      bits -= 5;
+    }
+  }
+  if (bits > 0) out += BASE32.charAt((value << (5 - bits)) & 31);
+  return out;
+}
+
+function _hashTag(secret, hashInput) {
+  var mac = nodeCrypto.createHmac("sha256", secret).update(hashInput.toLowerCase(), "utf8").digest();
+  return _base32Encode(mac.subarray(0, 4)).slice(0, 4);                                            // allow:raw-byte-literal — SRS spec 4-char short-tag
+}
+
+function _dayStamp(nowMs) {
+  // Days since epoch, mod 1024. Two-char base32 = 1024 possible values.
+  var days = Math.floor(nowMs / 86400000) % 1024;                                                  // allow:raw-byte-literal — ms-per-day + mod-1024 SRS rotation
+  return BASE32.charAt(days >>> 5) + BASE32.charAt(days & 31);                                     // allow:raw-byte-literal — 5-bit base32 split
+}
+
+function _dayDiff(stamp, nowMs) {
+  if (typeof stamp !== "string" || stamp.length !== 2) return Infinity;
+  var hi = BASE32.indexOf(stamp.charAt(0));
+  var lo = BASE32.indexOf(stamp.charAt(1));
+  if (hi < 0 || lo < 0) return Infinity;
+  var stampVal = (hi << 5) | lo;                                                                   // allow:raw-byte-literal — 5-bit base32 split
+  var nowVal = Math.floor(nowMs / 86400000) % 1024;                                                // allow:raw-byte-literal — ms-per-day + mod-1024 rotation
+  // Modular distance — assume positive (rewrites in the future are
+  // refused via _dayDiff > 0 callers).
+  var diff = (nowVal - stampVal + 1024) % 1024;                                                    // allow:raw-byte-literal — mod-1024 rotation
+  return diff;
+}
+
+/**
+ * @primitive b.mail.srs.create
+ * @signature b.mail.srs.create(opts)
+ * @since     0.8.89
+ * @status    stable
+ *
+ * Build an SRS rewriter bound to the operator's forwarder domain +
+ * HMAC signing secret. Returns `{ rewrite, reverse }`.
+ *
+ * @opts
+ *   secret:           string,   // operator's HMAC-SHA-256 signing secret (>=32 bytes recommended)
+ *   forwarderDomain:  string,   // the forwarder's own domain (where bounces land)
+ *   expiryDays:       number,   // default 30 — reject reverse() of rewrites older than this
+ *
+ * @example
+ *   var srs = b.mail.srs.create({
+ *     secret:          b.crypto.generateToken(64),
+ *     forwarderDomain: "forwarder.example",
+ *   });
+ *
+ *   // Inbound: alice@bob.com → forwarder → carol@dest.com
+ *   var rewritten = srs.rewrite("alice@bob.com");
+ *   // → "SRS0=HHHH=TT=bob.com=alice@forwarder.example"
+ *
+ *   // Bounce arrives back at SRS0=...; decode to deliver
+ *   var original = srs.reverse(rewritten);
+ *   // → "alice@bob.com"
+ */
+function create(opts) {
+  if (!opts || typeof opts !== "object") {
+    throw new SrsError("srs/bad-opts",
+      "srs.create: opts required (secret + forwarderDomain)", true);
+  }
+  validateOpts.requireNonEmptyString(
+    opts.secret, "srs.create.secret", SrsError, "srs/bad-secret");
+  validateOpts.requireNonEmptyString(
+    opts.forwarderDomain, "srs.create.forwarderDomain", SrsError, "srs/bad-forwarder");
+  if (opts.secret.length < 16) {                                                                   // allow:raw-byte-literal — minimum HMAC secret length
+    throw new SrsError("srs/bad-secret",
+      "srs.create: secret must be >= 16 chars (operator-supplied entropy floor)");
+  }
+  var expiryDays = opts.expiryDays !== undefined ? opts.expiryDays : 30;                           // allow:raw-byte-literal — default expiry window in days
+  if (typeof expiryDays !== "number" || !Number.isInteger(expiryDays) ||
+      expiryDays < 1 || expiryDays > 1024) {                                                       // allow:raw-byte-literal — SRS rotation cycle cap
+    throw new SrsError("srs/bad-expiry",
+      "srs.create: expiryDays must be an integer 1..1024 (SRS rotation cycle)");
+  }
+  var secret = opts.secret;
+  var forwarderDomain = opts.forwarderDomain;
+
+  function rewrite(originalAddress, nowMs) {
+    validateOpts.requireNonEmptyString(
+      originalAddress, "srs.rewrite.address", SrsError, "srs/bad-address");
+    var at = originalAddress.lastIndexOf("@");
+    if (at <= 0 || at === originalAddress.length - 1) {
+      throw new SrsError("srs/bad-address",
+        "srs.rewrite: address must be in localPart@domain form");
+    }
+    var localPart = originalAddress.slice(0, at);
+    var domain    = originalAddress.slice(at + 1);
+    if (localPart.length > 64 || domain.length > 253) {                                            // allow:raw-byte-literal — RFC 5321 local-part / domain caps
+      throw new SrsError("srs/bad-address",
+        "srs.rewrite: localPart / domain exceeds RFC 5321 length cap");
+    }
+    // Refuse SRS double-encoding from this primitive — operator must
+    // use srs1Rewrite() for already-SRS0 inputs (deferred per the
+    // v1-defensible decision: SRS1 wrapping is rare in operator
+    // deployments and adds substantial spec surface).
+    if (/^SRS[01]=/i.test(localPart)) {
+      throw new SrsError("srs/already-rewritten",
+        "srs.rewrite: address already SRS-encoded; chain forwarding through SRS1 is not yet supported (operator demand TBD)");
+    }
+    var now = typeof nowMs === "number" ? nowMs : Date.now();
+    var ts  = _dayStamp(now);
+    var hashInput = ts + "=" + domain + "=" + localPart;
+    var tag = _hashTag(secret, hashInput);
+    return "SRS0=" + tag + "=" + ts + "=" + domain + "=" + localPart + "@" + forwarderDomain;
+  }
+
+  function reverse(srsAddress, nowMs) {
+    validateOpts.requireNonEmptyString(
+      srsAddress, "srs.reverse.address", SrsError, "srs/bad-address");
+    var at = srsAddress.lastIndexOf("@");
+    if (at <= 0 || at === srsAddress.length - 1) {
+      throw new SrsError("srs/bad-address",
+        "srs.reverse: address must be in srsLocal@forwarder form");
+    }
+    var localPart  = srsAddress.slice(0, at);
+    var rcptDomain = srsAddress.slice(at + 1);
+    // Allow case-insensitive SRS0 prefix per the spec. Check this
+    // FIRST so an obviously-non-SRS0 input (`plain@example.com`)
+    // gets the specific not-srs0 verdict instead of the more general
+    // wrong-forwarder verdict.
+    if (!/^SRS0=/i.test(localPart)) {
+      throw new SrsError("srs/not-srs0",
+        "srs.reverse: address local-part does not start with SRS0=");
+    }
+    // Domain binding — the rewriter is scoped to a specific forwarder
+    // domain, and reverse() must verify the bounce arrived at THAT
+    // domain. Otherwise an SRS0 local-part signed with the same
+    // secret but addressed to a different forwarder (multi-domain
+    // deployment, or a misrouted DNS record) would still verify, and
+    // the operator would mis-deliver the bounce. RFC 5321 §2.3.5
+    // says domains are case-insensitive, so compare lowercased.
+    if (rcptDomain.toLowerCase() !== forwarderDomain.toLowerCase()) {
+      throw new SrsError("srs/wrong-forwarder",
+        "srs.reverse: bounce addressed to '" + rcptDomain + "' but rewriter " +
+        "is bound to forwarderDomain '" + forwarderDomain + "'");
+    }
+    var rest = localPart.slice(5);
+    var parts = rest.split("=");
+    if (parts.length < 4) {
+      throw new SrsError("srs/malformed",
+        "srs.reverse: expected SRS0=tag=ts=domain=local local-part shape (need >= 4 '=' fields)");
+    }
+    var tag = parts[0];
+    var ts  = parts[1];
+    var origDomain = parts[2];
+    var origLocal  = parts.slice(3).join("=");      // local-part may itself contain '='
+    // Verify tag.
+    var hashInput = ts + "=" + origDomain + "=" + origLocal;
+    var expectedTag = _hashTag(secret, hashInput);
+    if (!_timingSafeStringEqual(tag, expectedTag)) {
+      throw new SrsError("srs/bad-tag",
+        "srs.reverse: HMAC tag does not verify (wrong secret or tampered envelope-from)");
+    }
+    // Verify expiry window.
+    var now = typeof nowMs === "number" ? nowMs : Date.now();
+    var dayDiff = _dayDiff(ts, now);
+    if (dayDiff > expiryDays) {
+      throw new SrsError("srs/expired",
+        "srs.reverse: rewrite is " + dayDiff + " days old; expiry window is " + expiryDays + " days");
+    }
+    return origLocal + "@" + origDomain;
+  }
+
+  return Object.freeze({
+    rewrite:  rewrite,
+    reverse:  reverse,
+    forwarderDomain: forwarderDomain,
+  });
+}
+
+function _timingSafeStringEqual(a, b) {
+  if (typeof a !== "string" || typeof b !== "string") return false;
+  return bCrypto.timingSafeEqual(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
+}
+
+module.exports = {
+  create:   create,
+  SrsError: SrsError,
+};