Đảm bảo mã không an toàn không được sử dụng vô tình

Một hàm f()sử dụng eval()(hoặc một cái gì đó nguy hiểm) với dữ liệu mà tôi đã tạo và lưu trữ local_filetrên máy đang chạy chương trình của tôi:

import local_file

def f(str_to_eval):
    # code....
    # .... 
    eval(str_to_eval)    
    # ....
    # ....    
    return None


a = f(local_file.some_str)

f() chạy an toàn vì các chuỗi tôi cung cấp cho nó là của riêng tôi.

Tuy nhiên, nếu tôi từng quyết định sử dụng nó cho một cái gì đó không an toàn (ví dụ: đầu vào của người dùng) thì mọi thứ có thể trở nên cực kỳ sai lầm . Ngoài ra, nếu các local_fileđiểm dừng là cục bộ thì nó sẽ tạo ra một lỗ hổng vì tôi cũng cần phải tin vào máy cung cấp tệp đó.

Làm thế nào để tôi đảm bảo rằng tôi không bao giờ "quên" rằng chức năng này không an toàn để sử dụng (trừ khi các tiêu chí cụ thể được đáp ứng)?

_{Lưu ý: eval()là nguy hiểm và thường có thể được thay thế bằng một cái gì đó an toàn.}

Xác định một loại để trang trí đầu vào an toàn trên mạng. Trong hàm của bạn f(), xác nhận rằng đối số có loại này hoặc đưa ra lỗi. Hãy đủ thông minh để không bao giờ xác định một phím tắt def g(x): return f(SafeInput(x)).

Thí dụ:

class SafeInput(object):
  def __init__(self, value):
    self._value = value

  def value(self):
    return self._value

def f(safe_string_to_eval):
  assert type(safe_string_to_eval) is SafeInput, "safe_string_to_eval must have type SafeInput, but was {}".format(type(safe_string_to_eval))
  ...
  eval(safe_string_to_eval.value())
  ...

a = f(SafeInput(local_file.some_str))

Trong khi điều này có thể dễ dàng phá vỡ, nó làm cho nó khó khăn hơn để làm điều đó một cách tình cờ. Mọi người có thể chỉ trích một loại kiểm tra hà khắc như vậy, nhưng họ sẽ bỏ lỡ điểm. Vì SafeInputkiểu này chỉ là một kiểu dữ liệu và không phải là một lớp hướng đối tượng có thể được phân lớp, nên việc kiểm tra nhận dạng kiểu type(x) is SafeInputsẽ an toàn hơn so với việc kiểm tra tính tương thích của kiểu với isinstance(x, SafeInput). Vì chúng tôi muốn thực thi một loại cụ thể, bỏ qua loại rõ ràng và chỉ thực hiện gõ vịt ngầm cũng không thỏa đáng ở đây. Python có một hệ thống loại, vì vậy hãy sử dụng nó để nắm bắt những sai lầm có thể xảy ra!

Như Joel đã từng chỉ ra, làm cho mã sai nhìn sai (cuộn xuống phần "Giải pháp thực sự" hoặc tốt hơn là đọc nó hoàn toàn; nó đáng giá, ngay cả khi nó xử lý biến thay vì tên hàm). Vì vậy, tôi khiêm tốn đề nghị đổi tên chức năng của bạn thành một cái gì đó giống như f_unsafe_for_external_use()- rất có thể bạn sẽ tự mình nghĩ ra một số lược đồ viết tắt.

Chỉnh sửa: Tôi nghĩ đề xuất của amon là một biến thể dựa trên OO rất tốt trên cùng một chủ đề :-)

Bổ sung cho gợi ý của @amon, bạn cũng có thể suy nghĩ về việc kết hợp mẫu chiến lược ở đây, cũng như mẫu đối tượng phương thức.

class AbstractFoobarizer(object):
    def handle_cond(self, foo, bar):
        """
        Handle the event or something.
        """
        raise NotImplementedError

    def run(self):
        # do some magic
        pass

Và sau đó thực hiện 'bình thường'

class PrintingFoobarizer(AbstractFoobarizer):
    def handle_cond(self, foo, bar):
        print("Something went very well regarding {} and {}".format(foo, bar))

Và một triển khai admin-input-eval

class AdminControllableFoobarizer(AbstractFoobarizer):
    def handle_cond(self, foo, bar):
        # Look up code in database/config file/...
        code = get_code_from_settings()
        eval(code)

(Lưu ý: với một ví dụ thực tế, tôi có thể đưa ra một ví dụ tốt hơn).