Pastikan kode yang tidak aman tidak digunakan secara tidak sengaja

Fungsi f()menggunakan eval()(atau sesuatu yang berbahaya) dengan data yang saya buat dan simpan di local_filedalam mesin yang menjalankan program saya:

import local_file

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


a = f(local_file.some_str)

f() aman untuk dijalankan karena string yang saya berikan padanya adalah milik saya.

Namun, jika saya memutuskan untuk menggunakannya untuk sesuatu yang tidak aman (mis. Input pengguna) hal-hal bisa jadi sangat salah . Juga, jika local_fileberhenti menjadi lokal maka itu akan membuat kerentanan karena saya perlu mempercayai mesin yang menyediakan file itu juga.

Bagaimana saya harus memastikan bahwa saya tidak pernah "lupa" bahwa fungsi ini tidak aman untuk digunakan (kecuali kriteria tertentu terpenuhi)?

_{Catatan: eval()berbahaya dan biasanya bisa diganti dengan sesuatu yang aman.}

Tentukan jenis untuk menghias input "aman". Dalam fungsi Anda f(), nyatakan bahwa argumen memiliki tipe ini atau menimbulkan kesalahan. Cukup pintar untuk tidak pernah menentukan pintasan def g(x): return f(SafeInput(x)).

Contoh:

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))

Meskipun ini dapat dengan mudah dielakkan, itu membuatnya lebih sulit untuk melakukannya secara tidak sengaja. Orang mungkin mengkritik semacam cek kejam, tetapi mereka akan melewatkan intinya. Karena SafeInputtipe ini hanya tipe data dan bukan kelas berorientasi objek yang dapat disubklasifikasikan, memeriksa identitas tipe dengan type(x) is SafeInputlebih aman daripada memeriksa kompatibilitas tipe isinstance(x, SafeInput). Karena kami ingin menegakkan jenis tertentu, mengabaikan jenis eksplisit dan hanya melakukan pengetikan bebek secara implisit juga tidak memuaskan di sini. Python memiliki sistem tipe, jadi mari kita gunakan untuk menangkap kemungkinan kesalahan!

Seperti yang pernah ditunjukkan Joel, buat kode yang salah terlihat salah (gulir ke bawah ke bagian "Solusi Nyata", atau lebih baik baca sepenuhnya; itu sepadan, bahkan jika itu alamat variabel daripada nama fungsi). Jadi saya dengan rendah hati menyarankan untuk mengubah nama fungsi Anda menjadi sesuatu seperti f_unsafe_for_external_use()- Anda kemungkinan besar akan datang dengan beberapa skema singkatan sendiri.

Sunting: Saya pikir saran amon adalah variasi OO berdasarkan tema yang sangat bagus :-)

Melengkapi saran oleh @amon, Anda juga dapat berpikir tentang menggabungkan pola strategi di sini, serta pola objek metode.

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

    def run(self):
        # do some magic
        pass

Dan kemudian implementasi 'normal'

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

Dan implementasi 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)

(Catatan: dengan contoh dunia nyata, saya mungkin bisa memberikan contoh yang lebih baik).