dsh-vault 1.10.71 → 1.10.73

package/README-zh.md

@@ -324,19 +324,42 @@ npx dsh-vault list                                   # 或者干脆不装
 
 profile 这条路还有两个注意点:垫片可能被之后在该目录执行的 `pnpm install` 清掉;`pnpm dsh plugin --profile web add dsh-vault` 会依据包的 `dsh.bundle` 声明重整 `dsh.profile.bundles` —— 如果你自己的 patch 层**也**插入了这个插件,就会**挂两份**,要先删掉 patch 层那一行。
 
+## 泄露检查的隐私边界
+
+`vault_breach_check`(以及安全页)可以把密码拿去和 Have I Been Pwned 比对。**离开本机的只有一样东西**:
+
+```
+GET https://api.pwnedpasswords.com/range/<SHA-1(密码) 的前 5 个十六进制字符>
+Add-Padding: true
+```
+
+响应会返回该前缀桶里的**全部**后缀(几百条哈希),匹配在**本地**完成 —— 完整哈希、密码原文、以及它属于哪个条目都不会离开。如果密码已经在内置常见口令表里,**根本不会发起请求**;同一前缀的重复查询会在内存里缓存一小时。
+
+k-anonymity **没有**隐藏的东西,直说:
+
+- **5 个字符的前缀**(20 bit,约百万分之一桶)会连同你的 IP 发给 Cloudflare;
+- 能枚举候选口令的观察者,可以算出每个候选的前缀,从而看出你是否查询过那个桶 —— 这是该协议的已知局限,加请求头也解决不了;
+- `Add-Padding` 只是抹掉**响应体积**这个信号(不加它,桶的响应长度会和"该密码有多常见"相关)。
+
+如果连前缀都不想出去,就用 `online: false` —— 此时只查离线词表,覆盖率小得多,适合当筛子而不是定论。
+
 ## 强度指示
 
-列表里每个条目在标题后有一个**三星**强度指示 —— **☆☆☆ = 0 分,★★★ = 满分**,中间按半星分档。半星不是 Unicode 字符(大多数字体没有),而是把同样三个 `★` 复制一层、按百分比裁剪彩色层实现的:
+列表里每个条目在标题后有一个**三星**强度指示 —— **☆☆☆ = 0 分,★★★ = 满分**,中间按半星分档:
+
+![强度指示的七种状态](docs/strength-stars.svg)
+
+半星是**真正的左半实心、右半空心**,不是在旁边写个 `½`:实现是把同样三颗星叠两层、按百分比裁剪彩色层,而 `★`/`☆` 字宽一致,所以裁剪正好落在星的边界上。
 
-| 分数 | 显示 | 档位 |
+| 分数 | 实心星数 | 档位 |
 |---|---|---|
-| 0–8 | ☆☆☆ | 弱 |
-| 9–24 | ½☆☆ | 弱 |
-| 25–41 | ★☆☆ | 弱 |
-| 42–58 | ★½☆ | 中 |
-| 59–74 | ★★☆ | 中 |
-| 75–91 | ★★½ | 强 |
-| 92–100 | ★★★ | 强 |
+| 0–8 | 0 | 弱 |
+| 9–24 | ½ | 弱 |
+| 25–41 | 1 | 弱 |
+| 42–58 | 1½ | 中 |
+| 59–74 | 2 | 中 |
+| 75–91 | 2½ | 强 |
+| 92–100 | 3 | 很强 |
 
 悬停可看到精确分数与评价。分数在 **host 侧**计算(列表本身永远拿不到密钥),针对条目的**密码或银行卡 PIN**;机器生成的 API Key、私钥**故意不评分**,免得所有密钥都是满分。
 

package/README.md

@@ -359,22 +359,56 @@ Two more caveats on the profile route: its `.bin` shim can be pruned by a later
 patch layer *also* inserts the plugin, that mounts it twice, so remove the patch
 row first.
 
+## Privacy of the breach check
+
+`vault_breach_check` (and the security page) can check passwords against Have I
+Been Pwned. Exactly one thing leaves this machine:
+
+```
+GET https://api.pwnedpasswords.com/range/<FIRST 5 HEX CHARS OF SHA-1(password)>
+Add-Padding: true
+```
+
+The response lists every suffix in that bucket (hundreds of hashes) and the match
+is computed **locally** — the full hash, the password, and the entry it belongs to
+never leave. A password already in the bundled common-password list is answered
+offline and produces **no request at all**; repeat lookups of the same prefix are
+cached in memory for an hour.
+
+What k-anonymity does *not* hide, stated plainly:
+
+- the **five-character prefix** (20 bits, one bucket in ~1M) goes to Cloudflare,
+  together with your IP;
+- an observer who can guess candidate passwords can compute each candidate's
+  prefix and see whether you queried that bucket — that is the known limit of
+  this protocol, not something the header fixes;
+- `Add-Padding` only removes the *response-size* signal (without it, a bucket's
+  response length correlates with how common the password is).
+
+To keep even the prefix on your machine, pass `online: false` — the check then
+uses only the offline list, which is far smaller, so treat it as a screening aid
+rather than a verdict.
+
 ## Strength indicator
 
 Each entry row shows a three-star indicator after its title — **☆☆☆ = 0 score,
-★★★ = full marks** — in six half-star steps. A half star is the coloured copy of
-the same three glyphs clipped to a percentage (Unicode has no half-star glyph
-most fonts can render):
+★★★ = full marks** — in six half-star steps:
+
+![strength indicator: the seven states](docs/strength-stars.svg)
+
+A half star is a real half-filled star, not a `½` next to it: the coloured copy
+of the same three glyphs is clipped to a percentage, and `★`/`☆` share an advance
+width so the clip lands exactly on a star boundary.
 
-| score | shows | band |
+| score | filled stars | band |
 |---|---|---|
-| 0–8 | ☆☆☆ | weak |
-| 9–24 | ½☆☆ | weak |
-| 25–41 | ★☆☆ | weak |
-| 42–58 | ★½☆ | fair |
-| 59–74 | ★★☆ | fair |
-| 75–91 | ★★½ | strong |
-| 92–100 | ★★★ | strong |
+| 0–8 | 0 | weak |
+| 9–24 | ½ | weak |
+| 25–41 | 1 | weak |
+| 42–58 | 1½ | fair |
+| 59–74 | 2 | fair |
+| 75–91 | 2½ | strong |
+| 92–100 | 3 | very strong |
 
 Hovering it shows the exact score and verdict. The score is computed **host-side**
 (the list never receives the secret) and covers the entry's **password or card

package/lib/breach.js

@@ -17,8 +17,9 @@ const HIBP_RANGE_URL = 'https://api.pwnedpasswords.com/range/';
 const QUERY_TIMEOUT_MS = 12_000;
 /** How long a fetched prefix range is cached in memory. */
 const CACHE_TTL_MS = 60 * 60 * 1000;
-/** Common / weak passwords checked offline (rockyou-style head). */
-const WEAK_PASSWORDS = new Set([
+/** Common / weak passwords checked offline (rockyou-style head). Also used by
+ * the strength estimator, so both agree on what "known-common" means. */
+export const WEAK_PASSWORDS = new Set([
     '123456', 'password', '12345678', 'qwerty', '123456789', '12345', '1234', '111111',
     '1234567', 'dragon', '123123', 'baseball', 'abc123', 'football', 'monkey', 'letmein',
     'shadow', 'master', '666666', 'qwertyuiop', '123321', 'mustang', '1234567890', 'michael',
@@ -42,7 +43,13 @@ export function sha1Hex(password) {
 async function queryRange(prefix) {
     const res = await fetch(`${HIBP_RANGE_URL}${prefix}`, {
         signal: AbortSignal.timeout(QUERY_TIMEOUT_MS),
-        headers: { 'User-Agent': 'dsh-vault' },
+        headers: {
+            'User-Agent': 'dsh-vault',
+            // HIBP's own privacy knob: pad every response to a similar size so an
+            // observer cannot correlate a lookup with how many passwords share that
+            // prefix (which would leak information about how common yours is).
+            'Add-Padding': 'true',
+        },
     });
     if (!res.ok)
         throw new Error(`Pwned Passwords returned HTTP ${res.status}`);

package/lib/client.js

@@ -510,197 +510,197 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var VaultSection_module_css_default = {
-			"lenChips": "t_j5va_lenChips",
-			"totpRing": "t_j5va_totpRing",
-			"actionGroupLabel": "t_j5va_actionGroupLabel",
-			"detailActions": "t_j5va_detailActions",
+			"detailBox": "t_j5va_detailBox",
+			"secretField": "t_j5va_secretField",
+			"pwBar": "t_j5va_pwBar",
+			"customKeyInput": "t_j5va_customKeyInput",
+			"riskDanger": "t_j5va_riskDanger",
+			"strengthStars": "t_j5va_strengthStars",
+			"pwWeak": "t_j5va_pwWeak",
+			"importActions": "t_j5va_importActions",
+			"genOpts": "t_j5va_genOpts",
+			"vaultTarget": "t_j5va_vaultTarget",
 			"vaultManageRow": "t_j5va_vaultManageRow",
+			"importName": "t_j5va_importName",
+			"iconFieldWrap": "t_j5va_iconFieldWrap",
+			"copied": "t_j5va_copied",
+			"field": "t_j5va_field",
+			"rowExpired": "t_j5va_rowExpired",
+			"dangerButton": "t_j5va_dangerButton",
+			"auditChips": "t_j5va_auditChips",
+			"reportTitle": "t_j5va_reportTitle",
 			"healthBar": "t_j5va_healthBar",
-			"rowDue": "t_j5va_rowDue",
-			"dueBadge": "t_j5va_dueBadge",
-			"rowCheck": "t_j5va_rowCheck",
-			"editorBody": "t_j5va_editorBody",
-			"auditRow": "t_j5va_auditRow",
-			"totpCopy": "t_j5va_totpCopy",
-			"attachBox": "t_j5va_attachBox",
+			"pwStrong": "t_j5va_pwStrong",
+			"tagName": "t_j5va_tagName",
+			"healthSummary": "t_j5va_healthSummary",
+			"lenChip": "t_j5va_lenChip",
+			"genOptRow": "t_j5va_genOptRow",
 			"exportChips": "t_j5va_exportChips",
-			"customValueInput": "t_j5va_customValueInput",
-			"toolbarMain": "t_j5va_toolbarMain",
-			"gridDetail": "t_j5va_gridDetail",
-			"toolbar": "t_j5va_toolbar",
+			"riskBanner": "t_j5va_riskBanner",
+			"searchBox": "t_j5va_searchBox",
 			"list": "t_j5va_list",
-			"favToggle": "t_j5va_favToggle",
+			"moreButton": "t_j5va_moreButton",
+			"genHist": "t_j5va_genHist",
+			"reportLine": "t_j5va_reportLine",
+			"kindChip": "t_j5va_kindChip",
+			"customEq": "t_j5va_customEq",
+			"detailActions": "t_j5va_detailActions",
+			"identity": "t_j5va_identity",
+			"auditRow": "t_j5va_auditRow",
+			"toolbarDivider": "t_j5va_toolbarDivider",
+			"bulkCount": "t_j5va_bulkCount",
+			"histAdd": "t_j5va_histAdd",
+			"pinOff": "t_j5va_pinOff",
+			"brandGlyph": "t_j5va_brandGlyph",
+			"detailItem": "t_j5va_detailItem",
+			"empty": "t_j5va_empty",
+			"kindIcon": "t_j5va_kindIcon",
+			"auditWhen": "t_j5va_auditWhen",
+			"auditChipActive": "t_j5va_auditChipActive",
+			"badge": "t_j5va_badge",
+			"rowCheck": "t_j5va_rowCheck",
+			"riskWarn": "t_j5va_riskWarn",
+			"attachAdd": "t_j5va_attachAdd",
+			"tagRow": "t_j5va_tagRow",
+			"importList": "t_j5va_importList",
+			"emptyHint": "t_j5va_emptyHint",
 			"detailDeleteBtn": "t_j5va_detailDeleteBtn",
-			"exportChip": "t_j5va_exportChip",
-			"row": "t_j5va_row",
+			"gridRow": "t_j5va_gridRow",
+			"policyBar": "t_j5va_policyBar",
 			"addButton": "t_j5va_addButton",
-			"lockedBanner": "t_j5va_lockedBanner",
-			"detailRemain": "t_j5va_detailRemain",
-			"strengthFair": "t_j5va_strengthFair",
-			"searchBox": "t_j5va_searchBox",
-			"pwBar": "t_j5va_pwBar",
-			"tagName": "t_j5va_tagName",
-			"badge": "t_j5va_badge",
-			"importActions": "t_j5va_importActions",
-			"lenChipActive": "t_j5va_lenChipActive",
-			"toolbarDivider": "t_j5va_toolbarDivider",
-			"riskDanger": "t_j5va_riskDanger",
-			"badgeBtn": "t_j5va_badgeBtn",
-			"histDanger": "t_j5va_histDanger",
-			"emptyBox": "t_j5va_emptyBox",
+			"editor": "t_j5va_editor",
+			"genHistItem": "t_j5va_genHistItem",
+			"totp": "t_j5va_totp",
+			"badgeOk": "t_j5va_badgeOk",
 			"tabPane": "t_j5va_tabPane",
-			"reportLineLink": "t_j5va_reportLineLink",
-			"brandGlyphSm": "t_j5va_brandGlyphSm",
-			"strengthStars": "t_j5va_strengthStars",
-			"importDesc": "t_j5va_importDesc",
-			"actionBtn": "t_j5va_actionBtn",
-			"pwStrong": "t_j5va_pwStrong",
-			"recentChip": "t_j5va_recentChip",
-			"rowSelected": "t_j5va_rowSelected",
-			"tabs": "t_j5va_tabs",
+			"recentClear": "t_j5va_recentClear",
 			"kindChipActive": "t_j5va_kindChipActive",
-			"listCompact": "t_j5va_listCompact",
-			"identity": "t_j5va_identity",
-			"actionPrimary": "t_j5va_actionPrimary",
-			"pwHistRow": "t_j5va_pwHistRow",
-			"genHistItem": "t_j5va_genHistItem",
-			"editorActions": "t_j5va_editorActions",
-			"dangerButton": "t_j5va_dangerButton",
-			"histNeutral": "t_j5va_histNeutral",
+			"row": "t_j5va_row",
 			"kindFilter": "t_j5va_kindFilter",
-			"pwHistPwd": "t_j5va_pwHistPwd",
-			"gridActions": "t_j5va_gridActions",
-			"tabActive": "t_j5va_tabActive",
-			"inlineInput": "t_j5va_inlineInput",
-			"uriCode": "t_j5va_uriCode",
-			"tab": "t_j5va_tab",
-			"actionGroup": "t_j5va_actionGroup",
-			"kindIcon": "t_j5va_kindIcon",
-			"pinStar": "t_j5va_pinStar",
-			"backupButton": "t_j5va_backupButton",
-			"auditChipActive": "t_j5va_auditChipActive",
+			"dupMerge": "t_j5va_dupMerge",
+			"brandGlyphSm": "t_j5va_brandGlyphSm",
+			"rowDue": "t_j5va_rowDue",
+			"tagActions": "t_j5va_tagActions",
+			"vaultSwitch": "t_j5va_vaultSwitch",
 			"recentLabel": "t_j5va_recentLabel",
 			"badgeActive": "t_j5va_badgeActive",
-			"inlineField": "t_j5va_inlineField",
-			"bulkItem": "t_j5va_bulkItem",
-			"saveButton": "t_j5va_saveButton",
-			"srOnly": "t_j5va_srOnly",
-			"secretField": "t_j5va_secretField",
-			"genHist": "t_j5va_genHist",
-			"scoreRing": "t_j5va_scoreRing",
-			"selectActive": "t_j5va_selectActive",
-			"auditChips": "t_j5va_auditChips",
-			"badgeWarn": "t_j5va_badgeWarn",
-			"detailItem": "t_j5va_detailItem",
-			"colorSwatch": "t_j5va_colorSwatch",
-			"badgeLink": "t_j5va_badgeLink",
-			"customEq": "t_j5va_customEq",
-			"tagCount": "t_j5va_tagCount",
-			"recentSearch": "t_j5va_recentSearch",
-			"totp": "t_j5va_totp",
-			"revealButton": "t_j5va_revealButton",
-			"customFieldRow": "t_j5va_customFieldRow",
-			"genOpts": "t_j5va_genOpts",
-			"checkField": "t_j5va_checkField",
-			"resultCount": "t_j5va_resultCount",
-			"pwMeter": "t_j5va_pwMeter",
-			"tagManager": "t_j5va_tagManager",
+			"gridDetail": "t_j5va_gridDetail",
+			"detailCode": "t_j5va_detailCode",
+			"actionBtn": "t_j5va_actionBtn",
+			"lockedTag": "t_j5va_lockedTag",
+			"pinStar": "t_j5va_pinStar",
 			"toolbarFilters": "t_j5va_toolbarFilters",
-			"clearButton": "t_j5va_clearButton",
-			"rowActions": "t_j5va_rowActions",
-			"rowMain": "t_j5va_rowMain",
-			"headerMessage": "t_j5va_headerMessage",
-			"attachAdd": "t_j5va_attachAdd",
-			"empty": "t_j5va_empty",
-			"field": "t_j5va_field",
-			"reportBox": "t_j5va_reportBox",
-			"strengthTrack": "t_j5va_strengthTrack",
-			"colorFieldWrap": "t_j5va_colorFieldWrap",
-			"bulkBar": "t_j5va_bulkBar",
+			"modeAuto": "t_j5va_modeAuto",
+			"policyField": "t_j5va_policyField",
+			"revealButton": "t_j5va_revealButton",
 			"modeAsk": "t_j5va_modeAsk",
+			"actionGroupLabel": "t_j5va_actionGroupLabel",
+			"status": "t_j5va_status",
+			"rowMain": "t_j5va_rowMain",
+			"pinOn": "t_j5va_pinOn",
+			"gridInput": "t_j5va_gridInput",
 			"histLink": "t_j5va_histLink",
-			"reportTitle": "t_j5va_reportTitle",
-			"pwFair": "t_j5va_pwFair",
-			"colorPalette": "t_j5va_colorPalette",
-			"auditWhen": "t_j5va_auditWhen",
-			"editor": "t_j5va_editor",
-			"hit": "t_j5va_hit",
-			"tagRow": "t_j5va_tagRow",
-			"histUpdate": "t_j5va_histUpdate",
-			"importList": "t_j5va_importList",
-			"emojiBtn": "t_j5va_emojiBtn",
-			"iconFieldWrap": "t_j5va_iconFieldWrap",
-			"genOptRow": "t_j5va_genOptRow",
 			"title": "t_j5va_title",
-			"tagManagerHead": "t_j5va_tagManagerHead",
-			"importRow": "t_j5va_importRow",
-			"vaultTarget": "t_j5va_vaultTarget",
-			"emptyHint": "t_j5va_emptyHint",
-			"importName": "t_j5va_importName",
-			"badgeDanger": "t_j5va_badgeDanger",
-			"detailCode": "t_j5va_detailCode",
-			"copied": "t_j5va_copied",
-			"healthSummary": "t_j5va_healthSummary",
-			"moreWrap": "t_j5va_moreWrap",
-			"intro": "t_j5va_intro",
-			"auditChip": "t_j5va_auditChip",
-			"policyField": "t_j5va_policyField",
-			"dupGroup": "t_j5va_dupGroup",
-			"urlGlyph": "t_j5va_urlGlyph",
+			"lockedBanner": "t_j5va_lockedBanner",
+			"selectActive": "t_j5va_selectActive",
+			"backupButton": "t_j5va_backupButton",
+			"toolbar": "t_j5va_toolbar",
+			"importDesc": "t_j5va_importDesc",
 			"auditIssues": "t_j5va_auditIssues",
-			"riskBanner": "t_j5va_riskBanner",
-			"deleteButton": "t_j5va_deleteButton",
-			"dupMerge": "t_j5va_dupMerge",
-			"favActive": "t_j5va_favActive",
-			"copyAllBtn": "t_j5va_copyAllBtn",
-			"sortButton": "t_j5va_sortButton",
-			"pinOff": "t_j5va_pinOff",
-			"dupNames": "t_j5va_dupNames",
-			"retryButton": "t_j5va_retryButton",
-			"lenChip": "t_j5va_lenChip",
-			"customKeyInput": "t_j5va_customKeyInput",
-			"actionGroups": "t_j5va_actionGroups",
-			"strengthWeak": "t_j5va_strengthWeak",
-			"pinOn": "t_j5va_pinOn",
-			"rowExpired": "t_j5va_rowExpired",
-			"customFieldRows": "t_j5va_customFieldRows",
-			"detailBox": "t_j5va_detailBox",
-			"riskWarn": "t_j5va_riskWarn",
-			"moreButton": "t_j5va_moreButton",
-			"brandGlyph": "t_j5va_brandGlyph",
-			"recentClear": "t_j5va_recentClear",
-			"policyBar": "t_j5va_policyBar",
-			"reportSub": "t_j5va_reportSub",
-			"badgeOk": "t_j5va_badgeOk",
-			"gridRow": "t_j5va_gridRow",
+			"editorActions": "t_j5va_editorActions",
 			"gridName": "t_j5va_gridName",
-			"gridInput": "t_j5va_gridInput",
-			"moreMenu": "t_j5va_moreMenu",
+			"uriCode": "t_j5va_uriCode",
 			"section": "t_j5va_section",
-			"pwWeak": "t_j5va_pwWeak",
-			"kindChip": "t_j5va_kindChip",
-			"vaultHeader": "t_j5va_vaultHeader",
-			"strengthFill": "t_j5va_strengthFill",
+			"badgeLink": "t_j5va_badgeLink",
+			"favActive": "t_j5va_favActive",
+			"colorFieldWrap": "t_j5va_colorFieldWrap",
+			"detailRemain": "t_j5va_detailRemain",
+			"strengthTrack": "t_j5va_strengthTrack",
+			"searchKbd": "t_j5va_searchKbd",
+			"histUpdate": "t_j5va_histUpdate",
+			"actionPrimary": "t_j5va_actionPrimary",
+			"dupNames": "t_j5va_dupNames",
+			"totpCopy": "t_j5va_totpCopy",
+			"pwHistRow": "t_j5va_pwHistRow",
+			"badgeDanger": "t_j5va_badgeDanger",
+			"toolbarMain": "t_j5va_toolbarMain",
 			"strengthStrong": "t_j5va_strengthStrong",
-			"pwHistTime": "t_j5va_pwHistTime",
-			"reportJump": "t_j5va_reportJump",
+			"auditChip": "t_j5va_auditChip",
+			"pwFair": "t_j5va_pwFair",
+			"totpRing": "t_j5va_totpRing",
+			"tab": "t_j5va_tab",
+			"customFieldRows": "t_j5va_customFieldRows",
+			"favToggle": "t_j5va_favToggle",
+			"emojiBtn": "t_j5va_emojiBtn",
+			"tabActive": "t_j5va_tabActive",
+			"intro": "t_j5va_intro",
 			"pwLabel": "t_j5va_pwLabel",
-			"vaultSwitch": "t_j5va_vaultSwitch",
-			"reportLine": "t_j5va_reportLine",
-			"modeReadonly": "t_j5va_modeReadonly",
-			"error": "t_j5va_error",
-			"highBadge": "t_j5va_highBadge",
-			"bulkCount": "t_j5va_bulkCount",
-			"searchKbd": "t_j5va_searchKbd",
-			"modeAuto": "t_j5va_modeAuto",
 			"trashButton": "t_j5va_trashButton",
-			"emojiPicker": "t_j5va_emojiPicker",
-			"tagActions": "t_j5va_tagActions",
+			"hit": "t_j5va_hit",
+			"histDanger": "t_j5va_histDanger",
+			"histNeutral": "t_j5va_histNeutral",
+			"editorBody": "t_j5va_editorBody",
+			"highBadge": "t_j5va_highBadge",
 			"detailTotp": "t_j5va_detailTotp",
-			"histAdd": "t_j5va_histAdd",
-			"status": "t_j5va_status",
+			"reportJump": "t_j5va_reportJump",
+			"strengthFair": "t_j5va_strengthFair",
+			"colorSwatch": "t_j5va_colorSwatch",
+			"importRow": "t_j5va_importRow",
+			"exportChip": "t_j5va_exportChip",
+			"recentSearch": "t_j5va_recentSearch",
+			"recentChip": "t_j5va_recentChip",
+			"strengthWeak": "t_j5va_strengthWeak",
+			"emptyBox": "t_j5va_emptyBox",
+			"pwHistPwd": "t_j5va_pwHistPwd",
+			"scoreRing": "t_j5va_scoreRing",
+			"modeReadonly": "t_j5va_modeReadonly",
+			"badgeWarn": "t_j5va_badgeWarn",
+			"saveButton": "t_j5va_saveButton",
+			"bulkBar": "t_j5va_bulkBar",
+			"moreMenu": "t_j5va_moreMenu",
+			"dueBadge": "t_j5va_dueBadge",
+			"urlGlyph": "t_j5va_urlGlyph",
+			"retryButton": "t_j5va_retryButton",
+			"lenChips": "t_j5va_lenChips",
+			"lenChipActive": "t_j5va_lenChipActive",
+			"strengthFill": "t_j5va_strengthFill",
+			"tagManager": "t_j5va_tagManager",
+			"srOnly": "t_j5va_srOnly",
+			"resultCount": "t_j5va_resultCount",
+			"attachBox": "t_j5va_attachBox",
+			"tabs": "t_j5va_tabs",
+			"bulkItem": "t_j5va_bulkItem",
+			"reportBox": "t_j5va_reportBox",
+			"rowActions": "t_j5va_rowActions",
 			"pwHistBox": "t_j5va_pwHistBox",
-			"lockedTag": "t_j5va_lockedTag"
+			"reportLineLink": "t_j5va_reportLineLink",
+			"tagCount": "t_j5va_tagCount",
+			"actionGroups": "t_j5va_actionGroups",
+			"pwMeter": "t_j5va_pwMeter",
+			"colorPalette": "t_j5va_colorPalette",
+			"copyAllBtn": "t_j5va_copyAllBtn",
+			"customValueInput": "t_j5va_customValueInput",
+			"inlineInput": "t_j5va_inlineInput",
+			"emojiPicker": "t_j5va_emojiPicker",
+			"moreWrap": "t_j5va_moreWrap",
+			"gridActions": "t_j5va_gridActions",
+			"badgeBtn": "t_j5va_badgeBtn",
+			"dupGroup": "t_j5va_dupGroup",
+			"deleteButton": "t_j5va_deleteButton",
+			"pwHistTime": "t_j5va_pwHistTime",
+			"sortButton": "t_j5va_sortButton",
+			"tagManagerHead": "t_j5va_tagManagerHead",
+			"actionGroup": "t_j5va_actionGroup",
+			"error": "t_j5va_error",
+			"vaultHeader": "t_j5va_vaultHeader",
+			"checkField": "t_j5va_checkField",
+			"clearButton": "t_j5va_clearButton",
+			"headerMessage": "t_j5va_headerMessage",
+			"reportSub": "t_j5va_reportSub",
+			"rowSelected": "t_j5va_rowSelected",
+			"listCompact": "t_j5va_listCompact",
+			"customFieldRow": "t_j5va_customFieldRow",
+			"inlineField": "t_j5va_inlineField"
 		};
 		//#endregion
 		//#region src/client/VaultSection.tsx

package/lib/index.js

@@ -62,7 +62,8 @@ import { envLinesFor, shellQuote } from "./env-export.js";
 import { openVault, defaultVaultPath } from "./store.js";
 import { totp, parseTotpSecret, hotp, base32Decode } from "./totp.js";
 import { generatePassword, generatePassphrase } from "./password.js";
-import { checkPassword } from "./breach.js";
+import { checkPassword, WEAK_PASSWORDS } from "./breach.js";
+import { estimateStrength as estimateStrengthPure } from "./password-strength.js";
 import { readChromeLogins, defaultChromeLoginData, defaultChromeLocalState } from "./chrome.js";
 import { readKeychainPasswords, listKeychainEntries } from "./keychain.js";
 import { analyzeVault, analyzeEntry } from "./watchtower.js";
@@ -6540,6 +6541,14 @@ function entryPasswordStrength(entry) {
     const secret = passwordLikeSecret(entry);
     return secret === undefined ? undefined : estimateStrength(secret).score;
 }
+/** Strength with the bundled common-password list wired in, so a known-common
+ * password cannot score well on length alone. */
+function estimateStrength(password) {
+    const { score, verdict, feedback, bits } = estimateStrengthPure(password, WEAK_PASSWORDS);
+    // The tools and the UI meter take one line of prose; the array stays available
+    // to tests and to anything that wants the individual reasons.
+    return { score, verdict, feedback: feedback.join('; '), bits };
+}
 function toSummary(entry) {
     const strength = entryPasswordStrength(entry);
     return {
@@ -7179,58 +7188,8 @@ function pickDefinedFromRecord(record) {
 }
 /** Zero-dependency password strength estimator: score 0–100 from length,
  * character-class coverage, and penalties for common weak patterns. */
-function estimateStrength(password) {
-    let score = 0;
-    const length = password.length;
-    // Length is the dominant factor.
-    score += Math.min(45, length * 3);
-    const classes = [
-        /[a-z]/.test(password),
-        /[A-Z]/.test(password),
-        /[0-9]/.test(password),
-        /[^A-Za-z0-9]/.test(password),
-    ].filter(Boolean).length;
-    score += classes * 8;
-    // Diversity bonus for longer unique characters.
-    const unique = new Set(password).size;
-    score += Math.min(15, unique);
-    // Penalties for common weak patterns.
-    let feedback = [];
-    if (length < 8)
-        feedback.push('too short (aim ≥ 12)');
-    if (/^(password|123456|qwerty|letmein|admin|welcome|abc123)$/i.test(password)) {
-        score -= 40;
-        feedback.push('common password');
-    }
-    if (/(.)\1{2,}/.test(password)) {
-        score -= 8;
-        feedback.push('repeated characters');
-    }
-    if (/^\d+$/.test(password)) {
-        score -= 15;
-        feedback.push('digits only');
-    }
-    if (/^[a-z]+$/i.test(password)) {
-        score -= 10;
-        feedback.push('letters only');
-    }
-    if (password.length > 0 && new Set(password).size <= Math.max(3, Math.floor(length / 2)))
-        feedback.push('low diversity');
-    score = Math.max(0, Math.min(100, Math.round(score)));
-    const verdict = score >= 80 ? 'very strong' : score >= 60 ? 'strong' : score >= 40 ? 'fair' : 'weak';
-    // Entropy estimate in bits: log2(pool size) per character.
-    let pool = 0;
-    if (/[a-z]/.test(password))
-        pool += 26;
-    if (/[A-Z]/.test(password))
-        pool += 26;
-    if (/[0-9]/.test(password))
-        pool += 10;
-    if (/[^A-Za-z0-9]/.test(password))
-        pool += 33;
-    const bits = password.length > 0 && pool > 0 ? Math.round(password.length * Math.log2(pool)) : 0;
-    return { score, verdict, feedback: feedback.length > 0 ? feedback.join('; ') : 'no obvious weaknesses', bits };
-}
+// Strength lives in its own module so the CLI, the tools and the UI meter all
+// share one estimator (see src/password-strength.ts).
 /** Quote a value for safe use in .env / shell export (single-quote, escaping
  * embedded single quotes the POSIX way). */
 /** Generate a random username from adjective/noun syllables + digits. */

package/lib/password-strength.js

@@ -0,0 +1,170 @@
+/**
+ * Password strength, dependency-free.
+ *
+ * Two layers:
+ *
+ * 1. **Composition** — length, character classes and diversity, the cheap
+ *    signals every meter uses.
+ * 2. **Patterns** — what a cracker actually exploits: a known-common password
+ *    (including l33t and trailing-digit variants), a keyboard walk, a sequence,
+ *    a date, a repeated block, or "one word plus digits" (`Sunflower22`).
+ *
+ * A pattern does not just shave points: it **caps** the score, because a
+ * dictionary word with a capital and a couple of digits is not 67/100 material
+ * no matter how long it is. Composition alone rated exactly that kind of
+ * password "strong", which is the bug this module exists to fix.
+ *
+ * It is deliberately not zxcvbn: no bundled dictionary, no frequency ranking.
+ * The one wordlist it consults is the offline common-password set from
+ * `breach.ts`, so the strength meter and the breach report agree on what
+ * "known-common" means.
+ */
+import { WEAK_PASSWORDS } from "./breach.js";
+/** Substitute the usual l33t characters so `P@ssw0rd` matches `password`. */
+function deLeet(password) {
+    return password
+        .toLowerCase()
+        .replace(/[4@]/g, 'a')
+        .replace(/[3€]/g, 'e')
+        .replace(/[1!|]/g, 'i')
+        .replace(/0/g, 'o')
+        .replace(/[5$]/g, 's')
+        .replace(/7\+/g, 't');
+}
+/** The password with digits/symbols trimmed off both ends (for dictionary hits). */
+function coreLetters(password) {
+    return password.toLowerCase().replace(/^[^a-z]+|[^a-z]+$/g, '');
+}
+const KEYBOARD_RUNS = ['qwertyuiop', 'asdfghjkl', 'zxcvbnm', '1234567890', 'qazwsx', '1qaz2wsx'];
+const SEQUENCES = ['abcdefghijklmnopqrstuvwxyz', '01234567890'];
+/** True when the text contains a straight run of ≥4 characters from `source`. */
+function hasRun(text, source) {
+    for (let i = 0; i + 4 <= text.length; i++) {
+        const chunk = text.slice(i, i + 4);
+        if (source.includes(chunk))
+            return true;
+        if (source.includes([...chunk].reverse().join('')))
+            return true;
+    }
+    return false;
+}
+/** True for a repeated block: `abcabcabc`, `121212`. */
+function isRepeatedBlock(password) {
+    for (let size = 1; size <= Math.floor(password.length / 3); size++) {
+        const block = password.slice(0, size);
+        if (block.repeat(Math.ceil(password.length / size)).slice(0, password.length) === password)
+            return true;
+    }
+    return false;
+}
+/**
+ * True for a plausible date or year. Deliberately strict about separators: a
+ * bare four-digit run is a PIN or a sequence (`1111`), not a date, and calling it
+ * one used to add noise to the feedback.
+ */
+function hasDate(text) {
+    if (/(19|20)\d{2}/.test(text))
+        return true;
+    return /\d{1,2}[\/\-.]\d{1,2}[\/\-.]\d{2,4}/.test(text);
+}
+/** Score one password; `common` defaults to the bundled offline list. */
+export function estimateStrength(password, common = WEAK_PASSWORDS) {
+    const feedback = [];
+    const patterns = [];
+    const lower = password.toLowerCase();
+    const deLeeted = deLeet(password);
+    const letters = coreLetters(password);
+    // ---- layer 1: composition ------------------------------------------------
+    let score = Math.min(45, password.length * 3);
+    const classes = [/[a-z]/, /[A-Z]/, /[0-9]/, /[^A-Za-z0-9]/].filter(re => re.test(password)).length;
+    score += classes * 8;
+    score += Math.min(15, new Set(password).size);
+    if (password.length < 8)
+        feedback.push('too short (aim ≥ 12)');
+    if (/^\d+$/.test(password)) {
+        score -= 15;
+        feedback.push('digits only');
+    }
+    else if (/^[a-z]+$/i.test(password)) {
+        score -= 10;
+        feedback.push('letters only');
+    }
+    if (/(.)\1{2,}/.test(password)) {
+        score -= 8;
+        patterns.push('repeats');
+        feedback.push('repeated characters');
+    }
+    // ---- layer 2: patterns, each of which caps the score ---------------------
+    //
+    // The caps are length-aware for the *soft* patterns. A year inside a 30
+    // character passphrase (`CorrectHorseBatteryStaple!2024`) is not what makes it
+    // guessable, but the same year in an 8 character password is. A known-common
+    // password and a repeated block stay capped no matter how long they are: those
+    // are weak at any length.
+    const long = password.length >= 20;
+    let cap = 100;
+    const isCommon = (value) => common.has(value) || common.has(deLeet(value));
+    if (isCommon(lower) || isCommon(deLeeted)) {
+        cap = Math.min(cap, 5);
+        patterns.push('common');
+        feedback.push('found in common-password lists');
+    }
+    else if (letters.length >= 4 && isCommon(letters)) {
+        // a known word plus a suffix/prefix: `sunshine2024`, `Passw0rd!`
+        cap = Math.min(cap, long ? 50 : 25);
+        patterns.push('common-word');
+        feedback.push('a common password with numbers or symbols around it');
+    }
+    else if (/^[a-z]{5,}\d{1,4}!?$/i.test(password) || /^\d{1,4}[a-z]{5,}!?$/i.test(password)) {
+        // one dictionary-looking word plus a short number: `Sunflower22`
+        cap = Math.min(cap, long ? 65 : 45);
+        patterns.push('word+digits');
+        feedback.push('looks like a word plus digits — a dictionary attack covers it');
+    }
+    if (KEYBOARD_RUNS.some(run => hasRun(lower, run))) {
+        cap = Math.min(cap, long ? 50 : 30);
+        patterns.push('keyboard');
+        feedback.push('keyboard pattern (qwerty / asdf / 1234)');
+    }
+    if (SEQUENCES.some(seq => hasRun(lower, seq))) {
+        cap = Math.min(cap, long ? 50 : 35);
+        patterns.push('sequence');
+        feedback.push('sequential characters (abcd / 4321)');
+    }
+    if (hasDate(password)) {
+        cap = Math.min(cap, long ? 70 : 45);
+        patterns.push('date');
+        feedback.push('contains a date or year');
+    }
+    if (isRepeatedBlock(password)) {
+        cap = Math.min(cap, 30);
+        patterns.push('repeat-block');
+        feedback.push('a short block repeated over and over');
+    }
+    if (new Set(password).size <= Math.max(3, Math.floor(password.length / 2))) {
+        patterns.push('low-diversity');
+        feedback.push('low character diversity');
+    }
+    score = Math.max(0, Math.min(100, Math.round(Math.min(score, cap))));
+    const verdict = score >= 80 ? 'very strong' : score >= 60 ? 'strong' : score >= 40 ? 'fair' : 'weak';
+    // Naive entropy: pool size per character. Reported next to the score, not
+    // used to derive it — a 20-character `qwertyqwertyqwertyq` has plenty of bits
+    // and is still terrible.
+    let pool = 0;
+    if (/[a-z]/.test(password))
+        pool += 26;
+    if (/[A-Z]/.test(password))
+        pool += 26;
+    if (/[0-9]/.test(password))
+        pool += 10;
+    if (/[^A-Za-z0-9]/.test(password))
+        pool += 33;
+    const bits = password.length > 0 && pool > 0 ? Math.round(password.length * Math.log2(pool)) : 0;
+    return {
+        score,
+        verdict,
+        feedback: feedback.length > 0 ? feedback : ['no obvious weaknesses'],
+        bits,
+        patterns,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-vault",
-  "version": "1.10.71",
+  "version": "1.10.73",
   "bin": {
     "dsh-vault": "./lib/cli.js"
   },