contracts/CipherAuth.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {FHE, euint64, ebool, externalEuint64} from "@fhevm/solidity/lib/FHE.sol";
import {SepoliaConfig} from "@fhevm/solidity/config/ZamaConfig.sol";

contract CipherAuth is SepoliaConfig {
    // FHE-MFA Biometric Authentication State
    mapping(address => euint64[3]) private _registeredBiometrics;
    mapping(address => bool) private _hasBiometrics;
    uint32 public maxBiometricDrift = 15; // Manhattan distance tolerance
    mapping(address => bool) public biometricAuthPassed;
    mapping(uint256 => address) public biometricRequestUser;

    // FHE-Guard: Spam Filtering State
    mapping(address => uint32) public spamThreshold;
    mapping(address => uint256) public inboxCount;
    mapping(address => uint256) public spamInboxCount;
    mapping(uint256 => address) public spamCheckRequestUser;

    // FHE-Guard: Passwordless Auth State
    mapping(address => euint64) private _masterSecret;
    mapping(address => bool) private _hasSecret;
    mapping(address => uint64) public activeAuthChallenge;
    mapping(address => bool) public authPassed;
    mapping(uint256 => address) public authRequests;

    // FHE-Passport: Biometric Uniqueness State
    uint256 public passportCount;
    mapping(uint256 => euint64[3]) private _passportDatabase;
    mapping(address => bool) public hasPassport;
    mapping(uint256 => address) public passportRequests;
    mapping(address => bool) public passportUnique;
    mapping(uint256 => euint64[3]) private _pendingPassportTemplates;
    uint256 public nextTierRequestId = 1;

    // FHE-Aegis: AI Agent Behavior Drift State
    mapping(uint256 => euint64[3]) private _agentBaselines;
    mapping(uint256 => bool) private _hasBaseline;
    uint32 public maxBehaviorDrift = 1000; // squared Euclidean distance threshold
    mapping(uint256 => bool) public agentBehaviorCompromised;
    mapping(uint256 => uint256) public behaviorRequests;

    event BiometricsRegistered(address indexed user);
    event BiometricsVerified(address indexed user, bool success);
    event MessageSpamChecked(address indexed recipient, bool isSpam);
    event AuthSecretRegistered(address indexed user);
    event AuthChallengeGenerated(address indexed user, uint64 challenge);
    event AuthVerified(address indexed user, bool success);
    event PassportCheckRequested(address indexed user, uint256 indexed requestId);
    event PassportRegistered(address indexed user, bool success, uint256 passportId);
    event AgentBaselineRegistered(uint256 indexed agentId);
    event BehaviorCheckRequested(uint256 indexed agentId, uint256 indexed requestId);
    event BehaviorChecked(uint256 indexed agentId, bool compromised);

    // FHE-MFA: Biometric Authentication Implementation
    function registerBiometricSignature(
        externalEuint64 hX,
        externalEuint64 hY,
        externalEuint64 hZ,
        bytes calldata inputProof
    ) external {
        _registeredBiometrics[msg.sender][0] = FHE.fromExternal(hX, inputProof);
        _registeredBiometrics[msg.sender][1] = FHE.fromExternal(hY, inputProof);
        _registeredBiometrics[msg.sender][2] = FHE.fromExternal(hZ, inputProof);
        _hasBiometrics[msg.sender] = true;

        FHE.allowThis(_registeredBiometrics[msg.sender][0]);
        FHE.allowThis(_registeredBiometrics[msg.sender][1]);
        FHE.allowThis(_registeredBiometrics[msg.sender][2]);
        FHE.allow(_registeredBiometrics[msg.sender][0], msg.sender);
        FHE.allow(_registeredBiometrics[msg.sender][1], msg.sender);
        FHE.allow(_registeredBiometrics[msg.sender][2], msg.sender);

        emit BiometricsRegistered(msg.sender);
    }

    function requestBiometricAuth(
        externalEuint64 hX,
        externalEuint64 hY,
        externalEuint64 hZ,
        bytes calldata inputProof
    ) external returns (uint256 requestId) {
        address user = msg.sender;
        require(_hasBiometrics[user]);

        euint64 x = FHE.fromExternal(hX, inputProof);
        euint64 y = FHE.fromExternal(hY, inputProof);
        euint64 z = FHE.fromExternal(hZ, inputProof);

        euint64 dX = FHE.select(FHE.lt(x, _registeredBiometrics[user][0]), FHE.sub(_registeredBiometrics[user][0], x), FHE.sub(x, _registeredBiometrics[user][0]));
        euint64 dY = FHE.select(FHE.lt(y, _registeredBiometrics[user][1]), FHE.sub(_registeredBiometrics[user][1], y), FHE.sub(y, _registeredBiometrics[user][1]));
        euint64 dZ = FHE.select(FHE.lt(z, _registeredBiometrics[user][2]), FHE.sub(_registeredBiometrics[user][2], z), FHE.sub(z, _registeredBiometrics[user][2]));

        euint64 totalDist = FHE.add(FHE.add(dX, dY), dZ);
        ebool isValid = FHE.le(totalDist, FHE.asEuint64(maxBiometricDrift));
        FHE.allowThis(isValid);

        bytes32[] memory cts = new bytes32[](1);
        cts[0] = ebool.unwrap(isValid);

        requestId = FHE.requestDecryption(cts, this.fulfillBiometricAuth.selector);
        biometricRequestUser[requestId] = user;

        biometricAuthPassed[user] = false;
        emit BiometricsVerified(user, false);
    }

    function fulfillBiometricAuth(
        uint256 requestId,
        bytes memory cleartexts,
        bytes memory decryptionProof
    ) external {
        FHE.checkSignatures(requestId, cleartexts, decryptionProof);

        bool success = abi.decode(cleartexts, (bool));
        address user = biometricRequestUser[requestId];
        delete biometricRequestUser[requestId];

        biometricAuthPassed[user] = success;
        emit BiometricsVerified(user, success);
    }

    // FHE-Guard: Spam Filtering Implementation
    function setSpamThreshold(uint32 threshold) external {
        spamThreshold[msg.sender] = threshold;
    }

    function checkMessageSpam(
        address recipient,
        externalEuint64 wA,
        externalEuint64 wB,
        externalEuint64 wC,
        bytes calldata inputProof
    ) external returns (uint256 requestId) {
        if (spamThreshold[recipient] == 0) {
            spamThreshold[recipient] = 15; // default threshold
        }

        euint64 scoreA = FHE.fromExternal(wA, inputProof);
        euint64 scoreB = FHE.fromExternal(wB, inputProof);
        euint64 scoreC = FHE.fromExternal(wC, inputProof);

        euint64 totalScore = FHE.add(FHE.add(scoreA, scoreB), scoreC);
        ebool isSpam = FHE.gt(totalScore, FHE.asEuint64(spamThreshold[recipient]));

        FHE.allowThis(isSpam);

        bytes32[] memory cts = new bytes32[](1);
        cts[0] = ebool.unwrap(isSpam);

        requestId = FHE.requestDecryption(cts, this.fulfillSpamCheck.selector);
        spamCheckRequestUser[requestId] = recipient;
    }

    function fulfillSpamCheck(
        uint256 requestId,
        bytes memory cleartexts,
        bytes memory decryptionProof
    ) external {
        FHE.checkSignatures(requestId, cleartexts, decryptionProof);

        bool isSpam = abi.decode(cleartexts, (bool));
        address recipient = spamCheckRequestUser[requestId];
        delete spamCheckRequestUser[requestId];

        if (isSpam) {
            spamInboxCount[recipient]++;
        } else {
            inboxCount[recipient]++;
        }

        emit MessageSpamChecked(recipient, isSpam);
    }

    // FHE-Pass: Challenge-Response Implementation
    function registerAuthSecret(
        externalEuint64 hSecret,
        bytes calldata inputProof
    ) external {
        _masterSecret[msg.sender] = FHE.fromExternal(hSecret, inputProof);
        _hasSecret[msg.sender] = true;

        FHE.allowThis(_masterSecret[msg.sender]);
        FHE.allow(_masterSecret[msg.sender], msg.sender);

        emit AuthSecretRegistered(msg.sender);
    }

    function generateAuthChallenge(uint64 seedChallenge) external returns (uint64) {
        require(_hasSecret[msg.sender]);
        activeAuthChallenge[msg.sender] = seedChallenge;
        emit AuthChallengeGenerated(msg.sender, seedChallenge);
        return seedChallenge;
    }

    function verifyAuthChallenge(
        externalEuint64 hResponse,
        bytes calldata inputProof
    ) external returns (uint256 requestId) {
        address user = msg.sender;
        require(_hasSecret[user]);
        require(activeAuthChallenge[user] != 0);

        euint64 response = FHE.fromExternal(hResponse, inputProof);
        euint64 challengeVal = FHE.asEuint64(activeAuthChallenge[user]);
        euint64 expected = FHE.add(_masterSecret[user], challengeVal);

        ebool isValid = FHE.eq(response, expected);
        FHE.allowThis(isValid);

        bytes32[] memory cts = new bytes32[](1);
        cts[0] = ebool.unwrap(isValid);

        requestId = FHE.requestDecryption(cts, this.fulfillAuthCheck.selector);
        authRequests[requestId] = user;

        authPassed[user] = false;
        emit AuthVerified(user, false);
    }

    function fulfillAuthCheck(
        uint256 requestId,
        bytes memory cleartexts,
        bytes memory decryptionProof
    ) external {
        FHE.checkSignatures(requestId, cleartexts, decryptionProof);

        bool success = abi.decode(cleartexts, (bool));
        address user = authRequests[requestId];
        delete authRequests[requestId];

        authPassed[user] = success;
        emit AuthVerified(user, success);
    }

    // FHE-Passport: Biometric Uniqueness Check Implementation
    function requestPassportRegistration(
        externalEuint64 hX,
        externalEuint64 hY,
        externalEuint64 hZ,
        bytes calldata inputProof
    ) external returns (uint256 requestId) {
        address user = msg.sender;
        require(!hasPassport[user]);

        euint64 x = FHE.fromExternal(hX, inputProof);
        euint64 y = FHE.fromExternal(hY, inputProof);
        euint64 z = FHE.fromExternal(hZ, inputProof);

        uint256 nextReqId = nextTierRequestId++;
        _pendingPassportTemplates[nextReqId][0] = x;
        _pendingPassportTemplates[nextReqId][1] = y;
        _pendingPassportTemplates[nextReqId][2] = z;

        FHE.allowThis(_pendingPassportTemplates[nextReqId][0]);
        FHE.allowThis(_pendingPassportTemplates[nextReqId][1]);
        FHE.allowThis(_pendingPassportTemplates[nextReqId][2]);

        ebool isUnique = FHE.asEbool(true);

        for (uint256 i = 0; i < passportCount; i++) {
            euint64 dX = FHE.select(FHE.lt(x, _passportDatabase[i][0]), FHE.sub(_passportDatabase[i][0], x), FHE.sub(x, _passportDatabase[i][0]));
            euint64 dY = FHE.select(FHE.lt(y, _passportDatabase[i][1]), FHE.sub(_passportDatabase[i][1], y), FHE.sub(y, _passportDatabase[i][1]));
            euint64 dZ = FHE.select(FHE.lt(z, _passportDatabase[i][2]), FHE.sub(_passportDatabase[i][2], z), FHE.sub(z, _passportDatabase[i][2]));

            euint64 dist = FHE.add(FHE.add(dX, dY), dZ);
            ebool duplicate = FHE.le(dist, FHE.asEuint64(10));
            isUnique = FHE.and(isUnique, FHE.not(duplicate));
        }

        FHE.allowThis(isUnique);

        bytes32[] memory cts = new bytes32[](1);
        cts[0] = ebool.unwrap(isUnique);

        requestId = FHE.requestDecryption(cts, this.fulfillPassportCheck.selector);
        passportRequests[requestId] = user;
    }

    function fulfillPassportCheck(
        uint256 requestId,
        bytes memory cleartexts,
        bytes memory decryptionProof
    ) external {
        FHE.checkSignatures(requestId, cleartexts, decryptionProof);

        bool unique = abi.decode(cleartexts, (bool));
        address user = passportRequests[requestId];
        delete passportRequests[requestId];

        if (unique) {
            uint256 id = passportCount++;
            _passportDatabase[id][0] = _pendingPassportTemplates[requestId][0];
            _passportDatabase[id][1] = _pendingPassportTemplates[requestId][1];
            _passportDatabase[id][2] = _pendingPassportTemplates[requestId][2];

            FHE.allowThis(_passportDatabase[id][0]);
            FHE.allowThis(_passportDatabase[id][1]);
            FHE.allowThis(_passportDatabase[id][2]);

            hasPassport[user] = true;
            passportUnique[user] = true;
            emit PassportRegistered(user, true, id);
        } else {
            passportUnique[user] = false;
            emit PassportRegistered(user, false, 0);
        }
    }

    // FHE-Aegis: Behavioral Anomaly Detector Implementation
    function registerAgentBaseline(
        uint256 agentId,
        externalEuint64 hT,
        externalEuint64 hF,
        externalEuint64 hC,
        bytes calldata inputProof
    ) external {
        _agentBaselines[agentId][0] = FHE.fromExternal(hT, inputProof);
        _agentBaselines[agentId][1] = FHE.fromExternal(hF, inputProof);
        _agentBaselines[agentId][2] = FHE.fromExternal(hC, inputProof);
        _hasBaseline[agentId] = true;

        FHE.allowThis(_agentBaselines[agentId][0]);
        FHE.allowThis(_agentBaselines[agentId][1]);
        FHE.allowThis(_agentBaselines[agentId][2]);

        emit AgentBaselineRegistered(agentId);
    }

    function evaluateAgentBehavior(
        uint256 agentId,
        externalEuint64 hT,
        externalEuint64 hF,
        externalEuint64 hC,
        bytes calldata inputProof
    ) external returns (uint256 requestId) {
        require(_hasBaseline[agentId]);

        euint64 oT = FHE.fromExternal(hT, inputProof);
        euint64 oF = FHE.fromExternal(hF, inputProof);
        euint64 oC = FHE.fromExternal(hC, inputProof);

        euint64 bT = _agentBaselines[agentId][0];
        euint64 bF = _agentBaselines[agentId][1];
        euint64 bC = _agentBaselines[agentId][2];

        euint64 diffT = FHE.select(FHE.lt(oT, bT), FHE.sub(bT, oT), FHE.sub(oT, bT));
        euint64 diffF = FHE.select(FHE.lt(oF, bF), FHE.sub(bF, oF), FHE.sub(oF, bF));
        euint64 diffC = FHE.select(FHE.lt(oC, bC), FHE.sub(bC, oC), FHE.sub(oC, bC));

        euint64 drift = FHE.add(
            FHE.add(FHE.mul(diffT, diffT), FHE.mul(diffF, diffF)),
            FHE.mul(diffC, diffC)
        );

        ebool isCompromised = FHE.gt(drift, FHE.asEuint64(maxBehaviorDrift));
        FHE.allowThis(isCompromised);

        bytes32[] memory cts = new bytes32[](1);
        cts[0] = ebool.unwrap(isCompromised);

        requestId = FHE.requestDecryption(cts, this.fulfillBehaviorCheck.selector);
        behaviorRequests[requestId] = agentId;

        emit BehaviorCheckRequested(agentId, requestId);
    }

    function fulfillBehaviorCheck(
        uint256 requestId,
        bytes memory cleartexts,
        bytes memory decryptionProof
    ) external {
        FHE.checkSignatures(requestId, cleartexts, decryptionProof);

        bool isCompromised = abi.decode(cleartexts, (bool));
        uint256 agentId = behaviorRequests[requestId];
        delete behaviorRequests[requestId];

        agentBehaviorCompromised[agentId] = isCompromised;
        emit BehaviorChecked(agentId, isCompromised);
    }
}