rsnarsna
feat(security,codegen): Wave 2-5 node standardization, SSRF & AST hardening (DEC-015)
a724795 Download lambdas/codegen/emitters_strings_oop.py from Rsnarsna/auto: direct link, hf CLI and curl.
- Browser
- Download file 9.92 kB
-
https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/lambdas/codegen/emitters_strings_oop.py
- Command line
-
hf download hf://spaces/Rsnarsna/auto/lambdas/codegen/emitters_strings_oop.py
-
curl -L -o emitters_strings_oop.py https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/lambdas/codegen/emitters_strings_oop.py
9.92 kB
| """ | |
| ALLI Codegen Subpackage: Strings, OOP & Dynamic Module Emitters. | |
| """ | |
| import ast | |
| import re | |
| from typing import Optional, Tuple | |
| from language_core.codegen_contracts import ( | |
| BANNED_IMPORTS, DANGEROUS_CALLABLES, DANGEROUS_SPECIAL_ATTRS, RESTRICTED_HOST_MODULES, | |
| SAFE_RUNTIME_STDLIB_MODULES, STANDARD_LIBS, format_literal, sanitize_identifier, | |
| ) | |
| from language_core.nodes.nodes_oop import _parse_class_attributes | |
| from lambdas.codegen.context import NodeCodegenCtx | |
| _IDENT_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_]*$") | |
| def _is_safe_segment(seg: str) -> bool: | |
| return bool(_IDENT_RE.match(seg)) and seg not in RESTRICTED_HOST_MODULES and seg not in DANGEROUS_CALLABLES and not seg.startswith("__") | |
| def emit_string_and_oop_node(nctx: NodeCodegenCtx) -> Tuple[bool, Optional[str]]: | |
| raw_type, node_id, safe_id, params, cg = nctx.raw_type, nctx.node_id, nctx.safe_id, nctx.params, nctx.cg | |
| lines, ovm = cg.code_body_lines, cg.output_var_map | |
| if raw_type == "string.transform": | |
| txt_expr = nctx.resolve_input(["text", "text_in"], format_literal(params.get("text_in", params.get("text", "")))) | |
| nv = f"str_{safe_id}" | |
| op = str(params.get("operation", "upper")).lower() | |
| op = op if op in ("upper", "lower", "title", "strip", "capitalize", "swapcase") else "upper" | |
| lines.append(f" {nv} = {txt_expr}.{op}()") | |
| ovm.update({f"{node_id}:text_out": nv, f"{node_id}:result": nv, f"{node_id}:out": nv, f"{node_id}:length": f"len({nv})", node_id: nv}) | |
| return True, nv | |
| if raw_type == "string.concat": | |
| ae = nctx.resolve_input("a", format_literal(params.get("a", ""))) | |
| be = nctx.resolve_input("b", format_literal(params.get("b", ""))) | |
| sep, nv = params.get("separator", ""), f"concat_{safe_id}" | |
| lines.append(f" {nv} = str({ae}) + {format_literal(sep)} + str({be})" if sep else f" {nv} = str({ae}) + str({be})") | |
| ovm[f"{node_id}:length"] = f"len({nv})" | |
| return True, nv | |
| if raw_type == "string.split": | |
| txt_expr = nctx.resolve_input("text", format_literal(params.get("text", ""))) | |
| nv = f"split_{safe_id}" | |
| lines.append(f" {nv} = str({txt_expr}).split({format_literal(params.get('delimiter', ' '))})") | |
| ovm.update({f"{node_id}:items": nv, f"{node_id}:count": f"len({nv})"}) | |
| return True, nv | |
| if raw_type in ("oop.class_def", "class_def"): | |
| raw_cname = str(params.get("class_name", "Student")).strip() | |
| cname = sanitize_identifier(raw_cname, "Student") | |
| if not _IDENT_RE.match(cname) or cname.startswith("__"): | |
| cname = "Student" | |
| raw_attrs, attr_defaults = _parse_class_attributes(params.get("attributes", "name, score")) | |
| clean_attrs = [a for a in raw_attrs if _IDENT_RE.match(a) and not a.startswith("__") and a not in DANGEROUS_SPECIAL_ATTRS] | |
| attr_list = [sanitize_identifier(a) for a in clean_attrs] | |
| init_sig, has_def = [], False | |
| for raw_a, clean_a in zip(clean_attrs, attr_list): | |
| if raw_a in attr_defaults: | |
| has_def = True | |
| init_sig.append(f"{clean_a}={format_literal(attr_defaults[raw_a])}") | |
| else: | |
| init_sig.append(f"{clean_a}=None" if has_def else clean_a) | |
| sig_str = ", ".join(["self", *init_sig, "*_extra"]) if init_sig else "self, *_extra" | |
| nv = f"cls_{cname}_{safe_id}" | |
| doc = format_literal(str(params.get("docstring", "Class definition")).replace('"""', '')) | |
| lines.extend([f" class {cname}:", f" {doc}", f" def __init__({sig_str}):"]) | |
| lines.extend([f" self.{a} = {a}" for a in attr_list] if attr_list else [" pass"]) | |
| lines.append(f" {nv} = {cname}") | |
| ovm.update({f"{node_id}:class_ref": nv, f"{node_id}:class_name": format_literal(cname)}) | |
| return True, nv | |
| if raw_type in ("oop.instance", "instance"): | |
| cls_target = nctx.resolve_input("class_in", sanitize_identifier(params.get("class_name", "Student"), "Student")) | |
| arg1 = nctx.resolve_input("arg_1", format_literal(params.get("arg_1_val", "Alice"))) | |
| arg2 = nctx.resolve_input("arg_2", format_literal(params.get("arg_2_val", 85))) | |
| nv = f"inst_{safe_id}" | |
| lines.append(f" {nv} = {cls_target}({arg1}, {arg2})") | |
| ovm[f"{node_id}:instance"] = nv | |
| return True, nv | |
| if raw_type in ("oop.method_call", "method_call"): | |
| inst = nctx.resolve_input("instance_in", "self") | |
| mname = sanitize_identifier(params.get("method_name", "add_bonus"), "add_bonus") | |
| if not _IDENT_RE.match(mname) or mname.startswith("__"): | |
| mname = "add_bonus" | |
| raw_attr = str(params.get("attribute_to_modify", "score")).strip() | |
| if not _IDENT_RE.match(raw_attr) or raw_attr.startswith("__") or raw_attr in DANGEROUS_SPECIAL_ATTRS: | |
| raw_attr = "score" | |
| attr = raw_attr | |
| arg_val = nctx.resolve_input("arg", format_literal(params.get("default_arg", 15))) | |
| op = str(params.get("operation", "increment")).lower() | |
| nv = f"res_{safe_id}" | |
| if op in ("increment", "call_method"): | |
| lines.extend([ | |
| f" if hasattr({inst}, '{mname}'):", | |
| f" {nv} = {inst}.{mname}({arg_val})", | |
| " else:", | |
| f" setattr({inst}, '{attr}', getattr({inst}, '{attr}', 0) + {arg_val})", | |
| f" {nv} = getattr({inst}, '{attr}')", | |
| ]) | |
| elif op in ("set", "set_attr"): | |
| lines.extend([f" setattr({inst}, '{attr}', {arg_val})", f" {nv} = {arg_val}"]) | |
| else: | |
| lines.append(f" {nv} = getattr({inst}, '{attr}', None)") | |
| ovm.update({f"{node_id}:instance_out": inst, f"{node_id}:updated_instance": inst, f"{node_id}:result": nv, node_id: nv}) | |
| return True, nv | |
| return False, None | |
| def emit_module_and_fallback_node(nctx: NodeCodegenCtx) -> Tuple[bool, Optional[str]]: | |
| raw_type, node_id, safe_id, params, cg = nctx.raw_type, nctx.node_id, nctx.safe_id, nctx.params, nctx.cg | |
| lines, ovm = cg.code_body_lines, cg.output_var_map | |
| if raw_type in ("lang.import", "module.import", "core.import", "alli.lang.import", "alli.primitive.import", "alli.sys.import") or (raw_type.endswith(".import") and not raw_type.startswith("agent.")): | |
| mod = str(params.get("module_name") or "json").strip().lower() | |
| func_name, nv = str(params.get("function_name") or params.get("symbol") or "loads").strip(), f"res_{safe_id}" | |
| if mod in RESTRICTED_HOST_MODULES or mod not in SAFE_RUNTIME_STDLIB_MODULES: | |
| cg.diagnostics.append({"code": "CODEGEN-BANNED-MODULE", "severity": "error", "message": f"Restricted or unallowlisted module '{mod}' cannot be imported.", "node_id": node_id}) | |
| lines.append(f" {nv} = None") | |
| elif func_name and not _is_safe_segment(func_name): | |
| cg.diagnostics.append({"code": "CODEGEN-SECURITY-VIOLATION", "severity": "error", "message": f"Restricted or invalid symbol '{func_name}' for module '{mod}'.", "node_id": node_id}) | |
| lines.append(f" {nv} = None") | |
| else: | |
| cg.discovered_modules.add(mod) | |
| if mod not in STANDARD_LIBS: | |
| cg.discovered_requirements.add(mod) | |
| default_in = params.get("default_input") if params.get("default_input") is not None else ('{"name": "Alice", "score": 95}' if mod == "json" else (16 if func_name == "sqrt" else "None")) | |
| in_expr = nctx.resolve_input("data_in", nctx.resolve_input("in", nctx.resolve_input("payload", format_literal(default_in)))) | |
| if func_name: | |
| if func_name == "now" and mod == "datetime": | |
| lines.append(f" {nv} = datetime.datetime.now().isoformat()") | |
| else: | |
| lines.append(f" {nv} = {mod}.{func_name}({in_expr})" if (in_expr and in_expr != "None") else f" {nv} = {mod}.{func_name}()") | |
| else: | |
| nv = f"mod_{safe_id}" | |
| lines.append(f" {nv} = {mod}") | |
| ovm.update({f"{node_id}:result": nv, f"{node_id}:val": nv, f"{node_id}:out": nv, f"{node_id}:module_ref": format_literal(mod), node_id: nv}) | |
| return True, nv | |
| from lambdas.codegen.emitters_libraries import emit_python_library_preset_node | |
| handled_preset, preset_var = emit_python_library_preset_node(nctx) | |
| if handled_preset: | |
| return True, preset_var | |
| if "." in raw_type and not any(raw_type.startswith(f"{p}.") for p in BANNED_IMPORTS): | |
| parts = raw_type.split(".") | |
| mod, nv = parts[0], f"{parts[-1]}_{safe_id}" | |
| if mod in RESTRICTED_HOST_MODULES or not all(_is_safe_segment(p) for p in parts): | |
| cg.diagnostics.append({"code": "CODEGEN-BANNED-MODULE", "severity": "error", "message": f"Restricted module or symbol '{raw_type}' cannot be emitted.", "node_id": node_id}) | |
| lines.append(f" {nv} = None") | |
| return True, nv | |
| cg.discovered_modules.add(mod) | |
| if mod not in STANDARD_LIBS: | |
| cg.discovered_requirements.add(mod) | |
| arg_list = [ovm.get(f"{inc.get('source') or inc.get('from_node')}:{inc.get('source_handle') or inc.get('sourceHandle') or ''}") or ovm.get(str(inc.get("source") or inc.get("from_node"))) or "None" for inc in nctx.incoming] if nctx.incoming else [format_literal(v) for k, v in params.items() if k not in ("label", "node_type", "nodeType")] | |
| lines.append(f" {nv} = {raw_type}({', '.join(arg_list)})") | |
| return True, nv | |
| nv = sanitize_identifier(params.get("var_name"), f"step_{cg.step_counter}_{safe_id}") | |
| if nctx.incoming: | |
| lines.append(f" {nv} = {nctx.resolve_input('in', nctx.resolve_input('value', 'None'))}") | |
| else: | |
| lines.append(f" {nv} = {format_literal(params.get('value', params.get('literal_value', 'None')))}") | |
| return True, nv | |