typescript-virtual-container 1.4.4 → 1.4.6

package/src/SSHMimic/sftp.js

@@ -1,619 +0,0 @@
-/** biome-ignore-all lint/style/useNamingConvention: const as enum */
-import { EventEmitter } from "node:events";
-import * as path from "node:path";
-import { Server as SshServer } from "ssh2";
-import { createPerfLogger } from "../utils/perfLogger";
-import { VirtualShell } from "../VirtualShell";
-import { loadOrCreateHostKey } from "./hostKey";
-// ── Dev-mode logger — silent in production ────────────────────────────────────
-const DEV = !!process.env.DEV_MODE;
-const devLog = DEV ? console.log.bind(console) : () => { };
-const devWarn = DEV ? console.warn.bind(console) : () => { };
-const devErr = DEV ? console.error.bind(console) : () => { };
-const SFTP_STATUS_CODE = {
-    OK: 0,
-    EOF: 1,
-    NO_SUCH_FILE: 2,
-    PERMISSION_DENIED: 3,
-    FAILURE: 4,
-    BAD_MESSAGE: 5,
-    NO_CONNECTION: 6,
-    CONNECTION_LOST: 7,
-    OP_UNSUPPORTED: 8,
-};
-const OPEN_MODE = {
-    READ: 0x00000001,
-    WRITE: 0x00000002,
-    APPEND: 0x00000004,
-    CREAT: 0x00000008,
-    TRUNC: 0x00000010,
-    EXCL: 0x00000020,
-};
-const perf = createPerfLogger("SftpMimic");
-export class SftpMimic extends EventEmitter {
-    port;
-    server;
-    hostname;
-    shell;
-    vfs;
-    users;
-    nextHandleId = 0;
-    handles = new Map();
-    constructor({ port, hostname = "typescript-vm", shell, vfs, users, }) {
-        super();
-        perf.mark("constructor");
-        this.port = port;
-        this.server = null;
-        this.hostname = hostname;
-        this.shell = null;
-        if (shell) {
-            this.vfs = shell.vfs;
-            this.users = shell.users;
-            this.hostname = shell.hostname;
-            this.shell = shell;
-        }
-        else if (vfs && users) {
-            this.vfs = vfs;
-            this.users = users;
-        }
-        else {
-            const defaultShell = new VirtualShell(hostname);
-            this.vfs = defaultShell.vfs;
-            this.users = defaultShell.users;
-            this.shell = defaultShell;
-        }
-    }
-    getVfs() {
-        return this.shell?.vfs ?? this.vfs;
-    }
-    getUsers() {
-        return this.shell?.users ?? this.users;
-    }
-    async start() {
-        perf.mark("start");
-        const privateKey = loadOrCreateHostKey();
-        // Ensure VirtualShell is fully initialized before accepting connections
-        if (this.shell) {
-            await this.shell.ensureInitialized();
-        }
-        else {
-            // If using standalone VFS+Users, initialize users now
-            await this.users.initialize();
-        }
-        this.server = new SshServer({
-            hostKeys: [privateKey],
-            ident: `SSH-2.0-${this.hostname}`,
-        }, (client) => {
-            const allowedAuthMethods = [
-                "password",
-                "keyboard-interactive",
-            ];
-            let authUser = "root";
-            let sessionId = null;
-            let remoteAddress = "unknown";
-            this.emit("client:connect");
-            // Add error handling for the client
-            client.on("error", (error) => {
-                devErr(`[SFTP] Client error:`, error);
-            });
-            const acceptSession = (username) => {
-                authUser = username;
-                sessionId = this.getUsers().registerSession(authUser, remoteAddress).id;
-                const homeRoot = "/home";
-                if (!this.getVfs().exists(homeRoot)) {
-                    this.getVfs().mkdir(homeRoot, 0o755);
-                }
-                const homePath = `/home/${authUser}`;
-                if (!this.getVfs().exists(homePath)) {
-                    this.getVfs().mkdir(homePath, 0o755);
-                    this.getVfs().writeFile(`${homePath}/README.txt`, `Welcome to ${this.hostname}`);
-                    void this.getVfs().flushMirror();
-                }
-            };
-            client.on("authentication", (ctx) => {
-                const candidateUser = ctx.username || "root";
-                remoteAddress = ctx.ip ?? remoteAddress;
-                devLog(`[SFTP] Auth attempt: user=${candidateUser}, method=${ctx.method}, ip=${remoteAddress}`);
-                if (ctx.method === "password") {
-                    // If no password is set for the user, allow login without verification
-                    if (!this.getUsers().hasPassword(candidateUser)) {
-                        acceptSession(candidateUser);
-                        this.emit("auth:success", { username: authUser, remoteAddress });
-                        ctx.accept();
-                        return;
-                    }
-                    if (!this.getUsers().verifyPassword(candidateUser, ctx.password ?? "")) {
-                        this.emit("auth:failure", {
-                            username: candidateUser,
-                            remoteAddress,
-                        });
-                        ctx.reject(allowedAuthMethods);
-                        return;
-                    }
-                    acceptSession(candidateUser);
-                    this.emit("auth:success", { username: authUser, remoteAddress });
-                    ctx.accept();
-                    return;
-                }
-                if (ctx.method === "keyboard-interactive") {
-                    const keyboardCtx = ctx;
-                    // If no password is set, accept immediately
-                    if (!this.getUsers().hasPassword(candidateUser)) {
-                        acceptSession(candidateUser);
-                        this.emit("auth:success", { username: authUser, remoteAddress });
-                        keyboardCtx.accept();
-                        return;
-                    }
-                    keyboardCtx.prompt([{ prompt: "Password: ", echo: false }], (answers) => {
-                        const password = answers[0] ?? "";
-                        if (!this.getUsers().verifyPassword(candidateUser, password)) {
-                            this.emit("auth:failure", {
-                                username: candidateUser,
-                                remoteAddress,
-                            });
-                            keyboardCtx.reject(allowedAuthMethods);
-                            return;
-                        }
-                        acceptSession(candidateUser);
-                        this.emit("auth:success", {
-                            username: authUser,
-                            remoteAddress,
-                        });
-                        keyboardCtx.accept();
-                    });
-                    return;
-                }
-                ctx.reject(allowedAuthMethods);
-            });
-            client.on("close", () => {
-                this.getUsers().unregisterSession(sessionId);
-                this.emit("client:disconnect", { user: authUser });
-                sessionId = null;
-            });
-            client.on("ready", () => {
-                client.on("session", (accept, _reject) => {
-                    const session = accept();
-                    // Add error handling for the session
-                    session.on("error", (error) => {
-                        devErr(`[SFTP] Session error for user=${authUser}:`, error);
-                    });
-                    session.on("sftp", (acceptSftp) => {
-                        const sftp = acceptSftp();
-                        this.attachSftpHandlers(sftp, authUser);
-                    });
-                });
-            });
-        });
-        return new Promise((resolve, reject) => {
-            this.server?.once("error", (err) => reject(err));
-            this.server?.listen(this.port, "0.0.0.0", () => {
-                const address = this.server?.address();
-                const actualPort = address && typeof address === "object" && "port" in address
-                    ? address.port
-                    : this.port;
-                devLog(`SFTP Mimic listening on port ${actualPort}`);
-                this.emit("start", { port: actualPort });
-                resolve(actualPort);
-            });
-        });
-    }
-    stop() {
-        perf.mark("stop");
-        if (this.server) {
-            this.server.close(() => {
-                devLog("SFTP Mimic stopped");
-                this.emit("stop");
-            });
-        }
-    }
-    /**
-     * Resolves SFTP request paths with proper handling of relative paths.
-     * Relative paths (including ".") are resolved relative to the user's home directory.
-     * This is standard SFTP behavior where the "working directory" is always the home.
-     */
-    resolveRequestPath(requestPath, authUser) {
-        const homePath = `/home/${authUser}`;
-        // Empty path or "." → resolve to home directory
-        if (!requestPath || requestPath === ".") {
-            return homePath;
-        }
-        // Relative path (doesn't start with "/") → resolve relative to home
-        if (!requestPath.startsWith("/")) {
-            const joined = path.posix.join(homePath, requestPath);
-            return path.posix.normalize(joined);
-        }
-        // Absolute path → just normalize it
-        return path.posix.normalize(requestPath);
-    }
-    /**
-     * Verifies that a target path is confined within the user's home directory.
-     * This implements chroot-like behavior for security.
-     * @param targetPath - The normalized target path
-     * @param authUser - The authenticated username
-     * @returns true if path is within home, false if traversal attempt detected
-     */
-    isPathWithinHome(targetPath, authUser) {
-        const homePath = `/home/${authUser}`;
-        const normalized = path.posix.normalize(targetPath);
-        // Allow access to home directory itself
-        if (normalized === homePath) {
-            return true;
-        }
-        // Check if path is within home directory (starts with /home/username/)
-        if (normalized.startsWith(`${homePath}/`)) {
-            return true;
-        }
-        // Reject any attempt to escape home directory
-        return false;
-    }
-    createAttrs(node) {
-        const permissions = node.mode & 0o777;
-        const fileType = node.type === "directory" ? 0o040000 : 0o100000;
-        return {
-            mode: fileType | permissions,
-            size: node.type === "file" ? node.size : 0,
-            uid: 0,
-            gid: 0,
-            atime: Math.floor(node.createdAt.getTime() / 1000),
-            mtime: Math.floor(node.updatedAt.getTime() / 1000),
-        };
-    }
-    openHandle(handleValue) {
-        const handleId = ++this.nextHandleId;
-        const handle = Buffer.alloc(4);
-        handle.writeUInt32BE(handleId, 0);
-        this.handles.set(handle.toString("hex"), handleValue);
-        return handle;
-    }
-    getHandle(handle) {
-        return this.handles.get(handle.toString("hex"));
-    }
-    closeHandle(handle) {
-        this.handles.delete(handle.toString("hex"));
-    }
-    attachSftpHandlers(sftp, authUser) {
-        const getVfs = () => this.getVfs();
-        const getUsers = () => this.getUsers();
-        sftp.on("OPEN", (reqid, filename, flags) => {
-            const targetPath = this.resolveRequestPath(filename, authUser);
-            // Security: Confine to home directory
-            if (!this.isPathWithinHome(targetPath, authUser)) {
-                devWarn(`[SFTP] Path traversal attempt blocked: user=${authUser}, path=${targetPath}`);
-                sftp.status(reqid, SFTP_STATUS_CODE.PERMISSION_DENIED);
-                return;
-            }
-            const openMode = flags;
-            const _canRead = Boolean(openMode & OPEN_MODE.READ);
-            const _canWrite = Boolean(openMode & OPEN_MODE.WRITE || openMode & OPEN_MODE.APPEND);
-            const canCreate = Boolean(openMode & OPEN_MODE.CREAT);
-            const shouldTruncate = Boolean(openMode & OPEN_MODE.TRUNC);
-            try {
-                if (!getVfs().exists(targetPath)) {
-                    if (!canCreate) {
-                        sftp.status(reqid, SFTP_STATUS_CODE.NO_SUCH_FILE);
-                        return;
-                    }
-                    getVfs().writeFile(targetPath, Buffer.alloc(0));
-                }
-                const stats = getVfs().stat(targetPath);
-                if (stats.type === "directory") {
-                    sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-                    return;
-                }
-                let buffer = Buffer.from(getVfs().readFile(targetPath), "utf8");
-                if (shouldTruncate) {
-                    buffer = Buffer.alloc(0);
-                }
-                if (openMode & OPEN_MODE.APPEND) {
-                    const handle = this.openHandle({
-                        type: "file",
-                        path: targetPath,
-                        flags: openMode,
-                        buffer,
-                    });
-                    sftp.handle(reqid, handle);
-                    return;
-                }
-                const handle = this.openHandle({
-                    type: "file",
-                    path: targetPath,
-                    flags: openMode,
-                    buffer,
-                });
-                sftp.handle(reqid, handle);
-            }
-            catch (error) {
-                devErr("SFTP OPEN error:", error);
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-            }
-        });
-        sftp.on("READ", (reqid, handle, offset, length) => {
-            const entry = this.getHandle(handle);
-            if (!entry || entry.type !== "file") {
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-                return;
-            }
-            if (offset >= entry.buffer.length) {
-                sftp.status(reqid, SFTP_STATUS_CODE.EOF);
-                return;
-            }
-            const chunk = entry.buffer.slice(offset, offset + length);
-            sftp.data(reqid, chunk);
-        });
-        sftp.on("WRITE", async (reqid, handle, offset, data) => {
-            const entry = this.getHandle(handle);
-            if (!entry || entry.type !== "file") {
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-                return;
-            }
-            const end = offset + data.length;
-            if (end > entry.buffer.length) {
-                const nextBuffer = Buffer.alloc(end);
-                entry.buffer.copy(nextBuffer, 0, 0, entry.buffer.length);
-                entry.buffer = nextBuffer;
-            }
-            data.copy(entry.buffer, offset);
-            sftp.status(reqid, SFTP_STATUS_CODE.OK);
-        });
-        sftp.on("FSTAT", (reqid, handle) => {
-            const entry = this.getHandle(handle);
-            if (!entry) {
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-                return;
-            }
-            try {
-                const stats = getVfs().stat(entry.path);
-                sftp.attrs(reqid, this.createAttrs(stats));
-            }
-            catch {
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-            }
-        });
-        sftp.on("CLOSE", async (reqid, handle) => {
-            const entry = this.getHandle(handle);
-            if (!entry) {
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-                return;
-            }
-            if (entry.type === "file") {
-                try {
-                    getUsers().assertWriteWithinQuota(authUser, entry.path, entry.buffer);
-                    getVfs().writeFile(entry.path, entry.buffer);
-                    void getVfs().flushMirror();
-                }
-                catch (error) {
-                    devErr("SFTP CLOSE write error:", error);
-                    sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-                    this.closeHandle(handle);
-                    return;
-                }
-            }
-            this.closeHandle(handle);
-            sftp.status(reqid, SFTP_STATUS_CODE.OK);
-        });
-        sftp.on("OPENDIR", (reqid, requestPath) => {
-            const targetPath = this.resolveRequestPath(requestPath, authUser);
-            // Security: Confine to home directory
-            if (!this.isPathWithinHome(targetPath, authUser)) {
-                devWarn(`[SFTP] Path traversal attempt blocked: user=${authUser}, path=${targetPath}`);
-                sftp.status(reqid, SFTP_STATUS_CODE.PERMISSION_DENIED);
-                return;
-            }
-            try {
-                const stats = getVfs().stat(targetPath);
-                if (stats.type !== "directory") {
-                    sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-                    return;
-                }
-                const entries = getVfs().list(targetPath);
-                const handle = this.openHandle({
-                    type: "dir",
-                    path: targetPath,
-                    entries,
-                    index: 0,
-                });
-                sftp.handle(reqid, handle);
-            }
-            catch {
-                sftp.status(reqid, SFTP_STATUS_CODE.NO_SUCH_FILE);
-            }
-        });
-        sftp.on("READDIR", (reqid, handle) => {
-            const entry = this.getHandle(handle);
-            if (!entry || entry.type !== "dir") {
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-                return;
-            }
-            if (entry.index >= entry.entries.length) {
-                sftp.status(reqid, SFTP_STATUS_CODE.EOF);
-                return;
-            }
-            const filename = entry.entries[entry.index++];
-            const filePath = path.posix.join(entry.path, filename);
-            const stats = getVfs().stat(filePath);
-            const attrs = this.createAttrs(stats);
-            const longname = `${stats.type === "directory" ? "d" : "-"}${(stats.mode & 0o777).toString(8)} ${filename}`;
-            return sftp.name(reqid, [{ filename, longname, attrs }]);
-        });
-        sftp.on("STAT", (reqid, requestPath) => {
-            const targetPath = this.resolveRequestPath(requestPath, authUser);
-            // Security: Confine to home directory
-            if (!this.isPathWithinHome(targetPath, authUser)) {
-                devWarn(`[SFTP] Path traversal attempt blocked: user=${authUser}, path=${targetPath}`);
-                sftp.status(reqid, SFTP_STATUS_CODE.PERMISSION_DENIED);
-                return;
-            }
-            try {
-                const stats = getVfs().stat(targetPath);
-                sftp.attrs(reqid, this.createAttrs(stats));
-            }
-            catch {
-                sftp.status(reqid, SFTP_STATUS_CODE.NO_SUCH_FILE);
-            }
-        });
-        sftp.on("LSTAT", (reqid, requestPath) => {
-            const targetPath = this.resolveRequestPath(requestPath, authUser);
-            // Security: Confine to home directory
-            if (!this.isPathWithinHome(targetPath, authUser)) {
-                devWarn(`[SFTP] Path traversal attempt blocked: user=${authUser}, path=${targetPath}`);
-                sftp.status(reqid, SFTP_STATUS_CODE.PERMISSION_DENIED);
-                return;
-            }
-            try {
-                const stats = getVfs().stat(targetPath);
-                sftp.attrs(reqid, this.createAttrs(stats));
-            }
-            catch {
-                sftp.status(reqid, SFTP_STATUS_CODE.NO_SUCH_FILE);
-            }
-        });
-        sftp.on("FSETSTAT", (reqid, handle, attrs) => {
-            const entry = this.getHandle(handle);
-            if (!entry) {
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-                return;
-            }
-            try {
-                if (attrs.mode !== undefined) {
-                    getVfs().chmod(entry.path, attrs.mode);
-                }
-                sftp.status(reqid, SFTP_STATUS_CODE.OK);
-            }
-            catch {
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-            }
-        });
-        sftp.on("SETSTAT", (reqid, requestPath, attrs) => {
-            const targetPath = this.resolveRequestPath(requestPath, authUser);
-            // Security: Confine to home directory
-            if (!this.isPathWithinHome(targetPath, authUser)) {
-                devWarn(`[SFTP] Path traversal attempt blocked: user=${authUser}, path=${targetPath}`);
-                sftp.status(reqid, SFTP_STATUS_CODE.PERMISSION_DENIED);
-                return;
-            }
-            try {
-                if (attrs.mode !== undefined) {
-                    getVfs().chmod(targetPath, attrs.mode);
-                }
-                sftp.status(reqid, SFTP_STATUS_CODE.OK);
-            }
-            catch {
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-            }
-        });
-        sftp.on("REALPATH", (reqid, requestPath) => {
-            const normalized = this.resolveRequestPath(requestPath, authUser);
-            // Security: Confine to home directory
-            if (!this.isPathWithinHome(normalized, authUser)) {
-                devWarn(`[SFTP] Path traversal attempt blocked: user=${authUser}, path=${normalized}`);
-                sftp.status(reqid, SFTP_STATUS_CODE.PERMISSION_DENIED);
-                return;
-            }
-            sftp.name(reqid, [
-                {
-                    filename: normalized,
-                    longname: normalized,
-                    attrs: {
-                        mode: 0o040755,
-                        uid: 0,
-                        gid: 0,
-                        size: 0,
-                        atime: 0,
-                        mtime: 0,
-                    },
-                },
-            ]);
-        });
-        sftp.on("MKDIR", (reqid, requestPath) => {
-            const targetPath = this.resolveRequestPath(requestPath, authUser);
-            // Security: Confine to home directory
-            if (!this.isPathWithinHome(targetPath, authUser)) {
-                devWarn(`[SFTP] Path traversal attempt blocked: user=${authUser}, path=${targetPath}`);
-                sftp.status(reqid, SFTP_STATUS_CODE.PERMISSION_DENIED);
-                return;
-            }
-            try {
-                getVfs().mkdir(targetPath, 0o755);
-                void getVfs().flushMirror();
-                sftp.status(reqid, SFTP_STATUS_CODE.OK);
-            }
-            catch {
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-            }
-        });
-        sftp.on("RMDIR", (reqid, requestPath) => {
-            const targetPath = this.resolveRequestPath(requestPath, authUser);
-            // Security: Confine to home directory
-            if (!this.isPathWithinHome(targetPath, authUser)) {
-                devWarn(`[SFTP] Path traversal attempt blocked: user=${authUser}, path=${targetPath}`);
-                sftp.status(reqid, SFTP_STATUS_CODE.PERMISSION_DENIED);
-                return;
-            }
-            try {
-                getVfs().remove(targetPath, { recursive: false });
-                void getVfs().flushMirror();
-                sftp.status(reqid, SFTP_STATUS_CODE.OK);
-            }
-            catch {
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-            }
-        });
-        sftp.on("REMOVE", (reqid, requestPath) => {
-            const targetPath = this.resolveRequestPath(requestPath, authUser);
-            // Security: Confine to home directory
-            if (!this.isPathWithinHome(targetPath, authUser)) {
-                devWarn(`[SFTP] Path traversal attempt blocked: user=${authUser}, path=${targetPath}`);
-                sftp.status(reqid, SFTP_STATUS_CODE.PERMISSION_DENIED);
-                return;
-            }
-            try {
-                getVfs().remove(targetPath, { recursive: false });
-                void getVfs().flushMirror();
-                sftp.status(reqid, SFTP_STATUS_CODE.OK);
-            }
-            catch {
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-            }
-        });
-        sftp.on("RENAME", (reqid, oldPath, newPath) => {
-            const fromPath = this.resolveRequestPath(oldPath, authUser);
-            const toPath = this.resolveRequestPath(newPath, authUser);
-            // Security: Confine both source and destination to home directory
-            if (!this.isPathWithinHome(fromPath, authUser) ||
-                !this.isPathWithinHome(toPath, authUser)) {
-                devWarn(`[SFTP] Path traversal attempt blocked: user=${authUser}, from=${fromPath}, to=${toPath}`);
-                sftp.status(reqid, SFTP_STATUS_CODE.PERMISSION_DENIED);
-                return;
-            }
-            try {
-                getVfs().move(fromPath, toPath);
-                void getVfs().flushMirror();
-                sftp.status(reqid, SFTP_STATUS_CODE.OK);
-            }
-            catch {
-                sftp.status(reqid, SFTP_STATUS_CODE.FAILURE);
-            }
-        });
-        sftp.on("READLINK", (reqid) => {
-            sftp.status(reqid, SFTP_STATUS_CODE.OP_UNSUPPORTED);
-        });
-        sftp.on("SYMLINK", (reqid) => {
-            sftp.status(reqid, SFTP_STATUS_CODE.OP_UNSUPPORTED);
-        });
-        sftp.on("error", (error) => {
-            devErr(`[SFTP] Stream error for user=${authUser}:`, error);
-        });
-        sftp.on("close", () => {
-            devLog(`[SFTP] Stream closed for user=${authUser}`);
-            this.handles.clear();
-        });
-        sftp.on("end", () => {
-            devLog(`[SFTP] end event for user=${authUser}`);
-            this.handles.clear();
-        });
-        sftp.on("END", () => {
-            devLog(`[SFTP] END event for user=${authUser}`);
-            this.handles.clear();
-        });
-    }
-}

package/src/VirtualFileSystem/binaryPack.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"binaryPack.d.ts","sourceRoot":"","sources":["binaryPack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EACX,qBAAqB,EAGrB,MAAM,iBAAiB,CAAC;AA+EzB;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,qBAAqB,GAAG,MAAM,CAM7D;AA0FD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAiB5D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAErD"}