@snovon/solast 0.2.0

package/dist/detectors/fee-on-transfer-balance-mismatch.js

@@ -0,0 +1,394 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeeOnTransferBalanceMismatchDetector = void 0;
+const ast_1 = require("./_common/ast");
+const RULE_ID = 'fee-on-transfer-balance-mismatch';
+const PATTERN = `${RULE_ID}/requested-amount-booked`;
+const INCOMING_TRANSFER_MEMBERS = new Set([
+    'transfer',
+    'transferFrom',
+    'safeTransfer',
+    'safeTransferFrom',
+]);
+const ACCOUNTING_NAME_PARTS = [
+    'balance',
+    'credit',
+    'deposit',
+    'reserve',
+    'share',
+    'supply',
+    'asset',
+    'liquidity',
+];
+const ACCOUNTING_CALL_PARTS = [
+    'book',
+    'credit',
+    'deposit',
+    'mint',
+    'reserve',
+    'share',
+    'supply',
+];
+class FeeOnTransferBalanceMismatchDetector {
+    id = RULE_ID;
+    patternKey = RULE_ID;
+    supportedAstKinds = ['parser'];
+    descriptor = {
+        id: RULE_ID,
+        shortDescription: 'Incoming ERC20 transfer amount is booked directly into internal accounting without measuring the actual received token delta.',
+        helpUri: 'https://snovon.com/',
+        defaultSeverity: 'medium',
+    };
+    currentFile = '';
+    findings = [];
+    currentContractName = '';
+    currentContractNode = null;
+    currentContractIsConcrete = false;
+    currentStateVars = new Set();
+    functionStack = [];
+    setFile(file) {
+        this.currentFile = file;
+        this.findings = [];
+        this.currentContractName = '';
+        this.currentContractNode = null;
+        this.currentContractIsConcrete = false;
+        this.currentStateVars = new Set();
+        this.functionStack = [];
+    }
+    getFindings() {
+        return this.findings;
+    }
+    ContractDefinition(node) {
+        this.currentContractName = node?.name || '';
+        this.currentContractNode = node;
+        this.currentContractIsConcrete = node?.kind !== 'interface' && node?.kind !== 'library';
+        this.currentStateVars = new Set();
+        for (const sub of node?.subNodes || []) {
+            if ((0, ast_1.isNode)(sub, 'StateVariableDeclaration')) {
+                for (const variable of sub.variables || []) {
+                    if (variable?.name)
+                        this.currentStateVars.add(variable.name);
+                }
+            }
+            else if ((0, ast_1.isNode)(sub, 'VariableDeclaration') && sub?.isStateVar && sub?.name) {
+                this.currentStateVars.add(sub.name);
+            }
+        }
+    }
+    'ContractDefinition:exit'() {
+        this.currentContractName = '';
+        this.currentContractNode = null;
+        this.currentContractIsConcrete = false;
+        this.currentStateVars = new Set();
+    }
+    FunctionDefinition(node) {
+        if (!this.currentContractIsConcrete || !node?.body)
+            return;
+        const name = node?.name || (node?.isConstructor ? '<constructor>' : '<anonymous>');
+        this.functionStack.push({
+            node,
+            name,
+            transfers: [],
+            deltaVars: new Set(),
+            emitted: false,
+        });
+    }
+    'FunctionDefinition:exit'(node) {
+        if (!this.currentFunction())
+            return;
+        const top = this.currentFunction();
+        if (top?.node === node)
+            this.functionStack.pop();
+    }
+    VariableDeclarationStatement(node) {
+        const state = this.currentFunction();
+        if (!state)
+            return;
+        const initialValue = node?.initialValue;
+        if (!this.isReceivedDeltaExpression(initialValue))
+            return;
+        for (const variable of node?.variables || []) {
+            if (variable?.name)
+                state.deltaVars.add(variable.name);
+        }
+    }
+    FunctionCall(node) {
+        const state = this.currentFunction();
+        if (!state)
+            return;
+        const transfer = this.parseIncomingTransfer(node);
+        if (transfer) {
+            state.transfers.push(transfer);
+            return;
+        }
+        if (state.emitted || state.transfers.length === 0)
+            return;
+        if (!this.isAccountingCall(node))
+            return;
+        const transferWithBookedAmount = state.transfers.find(flow => this.argumentsContainKey(node?.arguments || [], flow.amountKey) &&
+            !this.argumentsContainDeltaVar(node?.arguments || [], state.deltaVars));
+        if (!transferWithBookedAmount)
+            return;
+        this.emitFinding(state, node, transferWithBookedAmount);
+    }
+    Assignment(node) {
+        this.handleAssignmentLike(node);
+    }
+    BinaryOperation(node) {
+        if (node?.operator !== '=' && node?.operator !== '+=')
+            return;
+        this.handleAssignmentLike(node);
+    }
+    handleAssignmentLike(node) {
+        const state = this.currentFunction();
+        if (!state)
+            return;
+        if (this.isIdentifierLike(node?.left) && this.isReceivedDeltaExpression(node?.right)) {
+            const name = this.rootIdentifierName(node.left);
+            if (name)
+                state.deltaVars.add(name);
+        }
+        if (state.emitted || state.transfers.length === 0)
+            return;
+        if (!this.isAccountingWriteTarget(node?.left))
+            return;
+        const transferWithBookedAmount = state.transfers.find(flow => this.expressionContainsKey(node?.right, flow.amountKey) &&
+            !this.expressionContainsDeltaVar(node?.right, state.deltaVars));
+        if (!transferWithBookedAmount)
+            return;
+        this.emitFinding(state, node, transferWithBookedAmount);
+    }
+    currentFunction() {
+        return this.functionStack[this.functionStack.length - 1];
+    }
+    parseIncomingTransfer(node) {
+        const callee = this.unwrapCallOptions(node?.expression);
+        if (!(0, ast_1.isNode)(callee, 'MemberAccess'))
+            return null;
+        const member = callee?.memberName || '';
+        if (!INCOMING_TRANSFER_MEMBERS.has(member))
+            return null;
+        const args = node?.arguments || [];
+        const shape = this.transferShape(member, args, callee?.expression);
+        if (!shape)
+            return null;
+        const amount = args[shape.amountIndex];
+        const amountKey = this.expressionKey(amount);
+        if (!amountKey)
+            return null;
+        if (!this.isAddressThis(args[shape.toIndex]))
+            return null;
+        return {
+            amountKey,
+            amountText: this.expressionLabel(amount),
+            node,
+        };
+    }
+    transferShape(member, args, calleeBase) {
+        const baseName = this.expressionKey(calleeBase);
+        const isStaticSafeErc20Call = baseName === 'SafeERC20';
+        if ((member === 'transferFrom' || member === 'safeTransferFrom') && args.length >= 3) {
+            if (member === 'safeTransferFrom' && isStaticSafeErc20Call && args.length >= 4) {
+                return { toIndex: 2, amountIndex: 3 };
+            }
+            return { toIndex: 1, amountIndex: 2 };
+        }
+        if ((member === 'transfer' || member === 'safeTransfer') && args.length >= 2) {
+            if (member === 'safeTransfer' && isStaticSafeErc20Call && args.length >= 3) {
+                return { toIndex: 1, amountIndex: 2 };
+            }
+            return { toIndex: 0, amountIndex: 1 };
+        }
+        return null;
+    }
+    isAccountingCall(node) {
+        const callee = this.unwrapCallOptions(node?.expression);
+        const name = (0, ast_1.isNode)(callee, 'MemberAccess') ? callee?.memberName : (0, ast_1.isNode)(callee, 'Identifier') ? callee?.name : '';
+        if (!name)
+            return false;
+        if (!/^[a-z_]/.test(name))
+            return false;
+        const lower = name.toLowerCase();
+        return ACCOUNTING_CALL_PARTS.some(part => lower.includes(part));
+    }
+    isAccountingWriteTarget(node) {
+        const root = this.rootIdentifierName(node);
+        if (!root || !this.currentStateVars.has(root))
+            return false;
+        if (this.isTokenHandleName(root))
+            return false;
+        const lower = root.toLowerCase();
+        return ACCOUNTING_NAME_PARTS.some(part => lower.includes(part));
+    }
+    isReceivedDeltaExpression(node) {
+        if (!(0, ast_1.isNode)(node, 'BinaryOperation') || node?.operator !== '-')
+            return false;
+        return (this.isBalanceOfThisCall(node?.left) && this.isIdentifierLike(node?.right)) || (this.isBalanceOfThisCall(node?.right) && this.isIdentifierLike(node?.left));
+    }
+    isBalanceOfThisCall(node) {
+        if (!(0, ast_1.isNode)(node, 'FunctionCall'))
+            return false;
+        const callee = this.unwrapCallOptions(node?.expression);
+        if (!(0, ast_1.isNode)(callee, 'MemberAccess') || callee?.memberName !== 'balanceOf')
+            return false;
+        const args = node?.arguments || [];
+        return args.length > 0 && this.isAddressThis(args[0]);
+    }
+    isAddressThis(node) {
+        if (!(0, ast_1.isNode)(node, 'FunctionCall'))
+            return false;
+        const callee = node?.expression;
+        const calleeName = (0, ast_1.isNode)(callee, 'Identifier') ? callee?.name : '';
+        if (calleeName !== 'address' && calleeName !== 'payable')
+            return false;
+        const args = node?.arguments || [];
+        return args.length === 1 && (0, ast_1.isNode)(args[0], 'Identifier') && args[0]?.name === 'this';
+    }
+    argumentsContainKey(args, key) {
+        return args.some(arg => this.expressionContainsKey(arg, key));
+    }
+    argumentsContainDeltaVar(args, deltaVars) {
+        return args.some(arg => this.expressionContainsDeltaVar(arg, deltaVars));
+    }
+    expressionContainsKey(node, key) {
+        if (!node || typeof node !== 'object')
+            return false;
+        if (this.expressionKey(node) === key)
+            return true;
+        if ((0, ast_1.isNode)(node, 'BinaryOperation')) {
+            return this.expressionContainsKey(node.left, key) || this.expressionContainsKey(node.right, key);
+        }
+        if ((0, ast_1.isNode)(node, 'UnaryOperation')) {
+            return this.expressionContainsKey(node.subExpression, key);
+        }
+        if ((0, ast_1.isNode)(node, 'Conditional')) {
+            return this.expressionContainsKey(node.condition, key) ||
+                this.expressionContainsKey(node.trueExpression, key) ||
+                this.expressionContainsKey(node.falseExpression, key);
+        }
+        if ((0, ast_1.isNode)(node, 'TupleExpression')) {
+            return (node.components || []).some((component) => this.expressionContainsKey(component, key));
+        }
+        if ((0, ast_1.isNode)(node, 'FunctionCall')) {
+            return (node.arguments || []).some((arg) => this.expressionContainsKey(arg, key));
+        }
+        if ((0, ast_1.isNode)(node, 'IndexAccess')) {
+            return this.expressionContainsKey(node.base, key) || this.expressionContainsKey(node.index, key);
+        }
+        if ((0, ast_1.isNode)(node, 'MemberAccess')) {
+            return this.expressionContainsKey(node.expression, key);
+        }
+        return false;
+    }
+    expressionContainsDeltaVar(node, deltaVars) {
+        if (!node || typeof node !== 'object' || deltaVars.size === 0)
+            return false;
+        if ((0, ast_1.isNode)(node, 'Identifier') && deltaVars.has(node?.name))
+            return true;
+        if (this.isReceivedDeltaExpression(node))
+            return true;
+        if ((0, ast_1.isNode)(node, 'BinaryOperation')) {
+            return this.expressionContainsDeltaVar(node.left, deltaVars) || this.expressionContainsDeltaVar(node.right, deltaVars);
+        }
+        if ((0, ast_1.isNode)(node, 'UnaryOperation')) {
+            return this.expressionContainsDeltaVar(node.subExpression, deltaVars);
+        }
+        if ((0, ast_1.isNode)(node, 'Conditional')) {
+            return this.expressionContainsDeltaVar(node.condition, deltaVars) ||
+                this.expressionContainsDeltaVar(node.trueExpression, deltaVars) ||
+                this.expressionContainsDeltaVar(node.falseExpression, deltaVars);
+        }
+        if ((0, ast_1.isNode)(node, 'TupleExpression')) {
+            return (node.components || []).some((component) => this.expressionContainsDeltaVar(component, deltaVars));
+        }
+        if ((0, ast_1.isNode)(node, 'FunctionCall')) {
+            return (node.arguments || []).some((arg) => this.expressionContainsDeltaVar(arg, deltaVars));
+        }
+        if ((0, ast_1.isNode)(node, 'IndexAccess')) {
+            return this.expressionContainsDeltaVar(node.base, deltaVars) || this.expressionContainsDeltaVar(node.index, deltaVars);
+        }
+        if ((0, ast_1.isNode)(node, 'MemberAccess')) {
+            return this.expressionContainsDeltaVar(node.expression, deltaVars);
+        }
+        return false;
+    }
+    expressionKey(node) {
+        if (!node || typeof node !== 'object')
+            return '';
+        if ((0, ast_1.isNode)(node, 'Identifier'))
+            return node?.name || '';
+        if ((0, ast_1.isNode)(node, 'NumberLiteral'))
+            return node?.number || '';
+        if ((0, ast_1.isNode)(node, 'BooleanLiteral'))
+            return String(node?.value);
+        if ((0, ast_1.isNode)(node, 'StringLiteral'))
+            return JSON.stringify(node?.value || '');
+        if ((0, ast_1.isNode)(node, 'MemberAccess')) {
+            const base = this.expressionKey(node.expression);
+            return base ? `${base}.${node.memberName || ''}` : node.memberName || '';
+        }
+        if ((0, ast_1.isNode)(node, 'IndexAccess')) {
+            return `${this.expressionKey(node.base)}[${this.expressionKey(node.index)}]`;
+        }
+        if ((0, ast_1.isNode)(node, 'FunctionCall')) {
+            const callee = this.expressionKey(node.expression);
+            const args = (node.arguments || []).map((arg) => this.expressionKey(arg)).join(',');
+            return `${callee}(${args})`;
+        }
+        return '';
+    }
+    expressionLabel(node) {
+        return this.expressionKey(node) || '<amount expression>';
+    }
+    rootIdentifierName(node) {
+        if (!node || typeof node !== 'object')
+            return '';
+        if ((0, ast_1.isNode)(node, 'Identifier'))
+            return node?.name || '';
+        if ((0, ast_1.isNode)(node, 'IndexAccess'))
+            return this.rootIdentifierName(node.base);
+        if ((0, ast_1.isNode)(node, 'MemberAccess'))
+            return this.rootIdentifierName(node.expression);
+        return '';
+    }
+    isIdentifierLike(node) {
+        return (0, ast_1.isNode)(node, 'Identifier') || (0, ast_1.isNode)(node, 'IndexAccess') || (0, ast_1.isNode)(node, 'MemberAccess');
+    }
+    unwrapCallOptions(node) {
+        if ((0, ast_1.isNode)(node, 'FunctionCallOptions'))
+            return node?.expression;
+        return node;
+    }
+    isTokenHandleName(name) {
+        const lower = name.toLowerCase();
+        return lower === 'token' || lower.endsWith('token') || lower === 'asset' || lower.endsWith('asset');
+    }
+    emitFinding(state, node, flow) {
+        const loc = (0, ast_1.assertLoc)(node, state.node);
+        state.emitted = true;
+        this.findings.push({
+            ruleId: RULE_ID,
+            pattern: PATTERN,
+            severity: 'medium',
+            confidence: 'medium',
+            file: this.currentFile,
+            line: loc.line,
+            column: loc.column,
+            endLine: loc.endLine,
+            endColumn: loc.endColumn,
+            contractName: this.currentContractName || '<anonymous>',
+            functionName: state.name,
+            message: `Fee-on-transfer balance mismatch in '${this.currentContractName}.${state.name}': ` +
+                `incoming token transfer requested ${flow.amountText}, then internal accounting books that requested amount instead of a balanceOf(address(this)) delta.`,
+            rationale: 'Fee-on-transfer and deflationary ERC20 tokens may deliver less than the requested transfer amount. ' +
+                'Accounting should use the actual received delta measured from the contract token balance.',
+            suggestedFix: 'Capture the token balance before and after the incoming transfer and credit the post-transfer delta, not the requested amount argument.',
+            sourceLocation: { line: loc.line, column: loc.column },
+            findingId: '',
+            contractHash: '',
+            transferLine: flow.node?.loc?.start?.line,
+        });
+    }
+}
+exports.FeeOnTransferBalanceMismatchDetector = FeeOnTransferBalanceMismatchDetector;
+//# sourceMappingURL=fee-on-transfer-balance-mismatch.js.map

package/dist/detectors/fhe-encrypted-input-validation.d.ts

@@ -0,0 +1,29 @@
+import type { ScanResult } from '../index';
+export declare class FheEncryptedInputValidationDetector {
+    readonly id = "fhe-encrypted-input-validation";
+    readonly patternKey = "fhe-encrypted-input-validation";
+    readonly supportedAstKinds: "parser"[];
+    private findings;
+    private currentFile;
+    private currentContract;
+    private currentFunction;
+    private currentFunctionNode;
+    private bytesInputs;
+    private inputRoots;
+    private verifiedInputs;
+    private hasAccessControl;
+    private hasSenderBinding;
+    setFile(file: string): void;
+    getFindings(): ScanResult[];
+    ContractDefinition(node: any): void;
+    ContractDefinition_post(_node: any): void;
+    FunctionDefinition(node: any): void;
+    FunctionDefinition_post(_node: any): void;
+    VariableDeclarationStatement(node: any): void;
+    IfStatement(node: any): void;
+    FunctionCall(node: any): void;
+    private recordVerifiedInput;
+    private rootInputName;
+    private makeFinding;
+    private resetFunction;
+}

package/dist/detectors/fhe-encrypted-input-validation.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FheEncryptedInputValidationDetector = void 0;
+const access_control_1 = require("./_common/access-control");
+const ast_1 = require("./_common/ast");
+const RULE_ID = 'fhe-encrypted-input-validation';
+const FHE_NAMESPACES = new Set(['TFHE', 'FHE']);
+const VERIFY_RE = /^verify/i;
+const AS_EUINT_RE = /^asEuint\d*$/;
+class FheEncryptedInputValidationDetector {
+    id = RULE_ID;
+    patternKey = RULE_ID;
+    supportedAstKinds = ['parser'];
+    findings = [];
+    currentFile = '';
+    currentContract = '';
+    currentFunction = '';
+    currentFunctionNode = null;
+    bytesInputs = new Set();
+    inputRoots = new Map();
+    verifiedInputs = new Set();
+    hasAccessControl = false;
+    hasSenderBinding = false;
+    setFile(file) {
+        this.currentFile = file;
+        this.findings = [];
+        this.currentContract = '';
+        this.resetFunction();
+    }
+    getFindings() {
+        return this.findings;
+    }
+    ContractDefinition(node) {
+        this.currentContract = node.name || '';
+    }
+    ContractDefinition_post(_node) {
+        this.currentContract = '';
+    }
+    FunctionDefinition(node) {
+        this.resetFunction();
+        this.currentFunctionNode = node;
+        this.currentFunction = node.isConstructor ? '<constructor>' : (node.name || '<anonymous>');
+        this.hasAccessControl = (0, access_control_1.hasRecognisedAccessControlModifier)(node);
+        for (const parameter of node.parameters || []) {
+            if (parameter?.name && isBytesType(parameter.typeName)) {
+                this.bytesInputs.add(parameter.name);
+                this.inputRoots.set(parameter.name, parameter.name);
+            }
+        }
+    }
+    FunctionDefinition_post(_node) {
+        this.resetFunction();
+    }
+    VariableDeclarationStatement(node) {
+        if (!this.currentFunction || !node.initialValue)
+            return;
+        const root = this.rootInputName(node.initialValue);
+        if (!root)
+            return;
+        for (const variable of node.variables || []) {
+            if (!variable?.name || !isBytesType(variable.typeName))
+                continue;
+            this.bytesInputs.add(variable.name);
+            this.inputRoots.set(variable.name, root);
+        }
+    }
+    IfStatement(node) {
+        if (!this.currentFunction)
+            return;
+        if (conditionBindsMsgSender(node.condition)) {
+            this.hasSenderBinding = true;
+        }
+    }
+    FunctionCall(node) {
+        if (!this.currentFunction)
+            return;
+        if (isRequireCall(node) && conditionBindsMsgSender(node.arguments?.[0])) {
+            this.hasSenderBinding = true;
+            return;
+        }
+        if (isFheVerifyCall(node)) {
+            this.recordVerifiedInput(node);
+            return;
+        }
+        if (!isFheAsEuintCall(node))
+            return;
+        const inputName = this.rootInputName(node.arguments?.[0]);
+        if (!inputName)
+            return;
+        if (this.hasAccessControl || this.hasSenderBinding || this.verifiedInputs.has(inputName))
+            return;
+        this.findings.push(this.makeFinding(node, inputName));
+    }
+    recordVerifiedInput(node) {
+        for (const arg of node.arguments || []) {
+            const inputName = this.rootInputName(arg);
+            if (inputName)
+                this.verifiedInputs.add(inputName);
+        }
+    }
+    rootInputName(node) {
+        if (!(0, ast_1.isNode)(node, 'Identifier'))
+            return '';
+        if (!this.bytesInputs.has(node.name))
+            return '';
+        return this.inputRoots.get(node.name) || node.name;
+    }
+    makeFinding(node, inputName) {
+        const primaryLoc = (0, ast_1.tryLoc)(node);
+        const line = primaryLoc?.line ?? (0, ast_1.tryLoc)(this.currentFunctionNode)?.line ?? 1;
+        const column = primaryLoc?.column ?? 0;
+        const endLine = primaryLoc?.endLine ?? line;
+        return {
+            file: this.currentFile,
+            contract: this.currentContract,
+            'function': this.currentFunction,
+            line,
+            endLine,
+            column,
+            pattern: RULE_ID,
+            confidence: 'medium',
+            ruleId: RULE_ID,
+            severity: 'medium',
+            category: 'vulnerability',
+            message: `Raw bytes parameter '${inputName}' is converted to an FHE ciphertext without a preceding provenance or sender-binding check.`,
+            rationale: 'Caller-supplied ciphertext bytes passed to TFHE.asEuint*/FHE.asEuint* should be verified or bound to msg.sender before ciphertext construction.',
+            suggestedFix: 'Call TFHE.verify*/FHE.verify* for the same bytes input before conversion, bind the input proof to msg.sender, or restrict the function with an access-control modifier.',
+            contractName: this.currentContract,
+            functionName: this.currentFunction,
+            sourceLocation: { line, column },
+            findingId: '',
+            contractHash: '',
+        };
+    }
+    resetFunction() {
+        this.currentFunction = '';
+        this.currentFunctionNode = null;
+        this.bytesInputs.clear();
+        this.inputRoots.clear();
+        this.verifiedInputs.clear();
+        this.hasAccessControl = false;
+        this.hasSenderBinding = false;
+    }
+}
+exports.FheEncryptedInputValidationDetector = FheEncryptedInputValidationDetector;
+function isBytesType(typeName) {
+    return (0, ast_1.isNode)(typeName, 'ElementaryTypeName') && typeName.name === 'bytes';
+}
+function isFheAsEuintCall(node) {
+    const member = fheMemberCall(node);
+    return !!member && AS_EUINT_RE.test(member.memberName || '');
+}
+function isFheVerifyCall(node) {
+    const member = fheMemberCall(node);
+    return !!member && VERIFY_RE.test(member.memberName || '');
+}
+function fheMemberCall(node) {
+    const callee = node?.expression;
+    if (!(0, ast_1.isNode)(callee, 'MemberAccess'))
+        return null;
+    if (!(0, ast_1.isNode)(callee.expression, 'Identifier'))
+        return null;
+    if (!FHE_NAMESPACES.has(callee.expression.name))
+        return null;
+    return callee;
+}
+function isRequireCall(node) {
+    const callee = node?.expression;
+    return (0, ast_1.isNode)(callee, 'Identifier') && (callee.name === 'require' || callee.name === 'assert');
+}
+function conditionBindsMsgSender(node) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if ((0, ast_1.isNode)(node, 'BinaryOperation') && (node.operator === '==' || node.operator === '!=')) {
+        return containsMsgSender(node.left) || containsMsgSender(node.right);
+    }
+    return containsNode(node, (current) => ((0, ast_1.isNode)(current, 'BinaryOperation') &&
+        (current.operator === '==' || current.operator === '!=') &&
+        (containsMsgSender(current.left) || containsMsgSender(current.right))));
+}
+function containsMsgSender(node) {
+    return containsNode(node, (current) => ((0, ast_1.isNode)(current, 'MemberAccess') &&
+        current.memberName === 'sender' &&
+        (0, ast_1.isNode)(current.expression, 'Identifier') &&
+        current.expression.name === 'msg'));
+}
+function containsNode(node, predicate, seen = new Set()) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (seen.has(node))
+        return false;
+    seen.add(node);
+    if (predicate(node))
+        return true;
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'loc' || key === 'range' || key === 'comments')
+            continue;
+        if (Array.isArray(value)) {
+            for (const child of value) {
+                if (containsNode(child, predicate, seen))
+                    return true;
+            }
+        }
+        else if (value && typeof value === 'object' && containsNode(value, predicate, seen)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=fhe-encrypted-input-validation.js.map

package/dist/detectors/fhe-handle-leakage.d.ts

@@ -0,0 +1,44 @@
+import type { ScanResult } from '../index';
+export declare class FheHandleLeakageDetector {
+    readonly id = "fhe-handle-leakage";
+    readonly patternKey = "fhe-handle-leakage";
+    readonly supportedAstKinds: "parser"[];
+    readonly enabledByDefault = false;
+    private findings;
+    private currentFile;
+    private currentContract;
+    private currentContractNode;
+    private stateVars;
+    private currentFunction;
+    private currentFunctionNode;
+    private currentFunctionVisibility;
+    private currentFunctionHasBody;
+    private currentFunctionHasAuthGuard;
+    private fheCreatedLocals;
+    private fheCreatedLocalPositions;
+    private grantedHandles;
+    private persistedHandles;
+    private currentModifier;
+    private currentModifierHasAuthGuard;
+    private authGuardModifiers;
+    setFile(file: string): void;
+    getFindings(): ScanResult[];
+    ContractDefinition(node: any): void;
+    ContractDefinition_post(_node: any): void;
+    ModifierDefinition(node: any): void;
+    ModifierDefinition_post(_node: any): void;
+    FunctionDefinition(node: any): void;
+    FunctionDefinition_post(_node: any): void;
+    VariableDeclarationStatement(node: any): void;
+    BinaryOperation(node: any): void;
+    IfStatement(node: any): void;
+    FunctionCall(node: any): void;
+    private recordAccessControlCall;
+    private recordAccessControlCondition;
+    private emitMissingAclFindings;
+    private hasGrantAfter;
+    private emitCallbackFinding;
+    private makeFinding;
+    private resetFunction;
+    private resetModifier;
+}