Python的可访问类变量，敏感数据和恶意编码器（黑帽黑客）

Question

我试图使正在执行的项目无法访问变量，并且遇到了有关Python是否在类中具有“私有”变量的SO文章。。对我来说，它提出了一些有趣的问题，为了使其更易回答，我将使用^Q1，^Q2等标签。我环顾四周，但是我没有找到要问的问题的答案，特别是那些关于敏感数据的人。

我在那篇文章中找到了有用的内容，但似乎大家的普遍共识是，如果您看到一个变量_之前带有一个变量，表现得像个成年人，并且意识到自己不应该弄乱它。对于以开头的变量提出了同样的想法__。在那里，我得到了你信任的人不使用像那些描述技巧的总体思路这里和（更详细）这里。我还在此SO帖子中找到了一些很好的信息。

当您谈论良好的编码实践时，这都是非常好的建议。

我在我分享的帖子的评论中发表了一些想法。我的主要问题被发布为评论。

我感到惊讶的是，对于想要引入恶意代码的人没有更多的讨论。这是一个真正的问题：有没有在Python没有办法阻止黑帽黑客访问你的变量和方法和插入代码/数据，可以拒绝服务，泄露个人（或控股公司）的信息^Q1？如果Python不允许这种类型的安全性，是否应该将其用于敏感数据^Q2？

我完全失去了一些东西：能不能恶意编码器，甚至访问的变量和方法来插入代码/数据，可以拒绝服务或泄露敏感数据^Q3？

我想我可能会误解一个概念，丢失某些东西，将问题放在不属于该问题的地方，或者只是完全不了解什么是计算机安全性。但是，我想了解这里发生了什么。如果我完全不合格，我想要一个能告诉我的答案，但是我也想知道我是如何完全不合格以及如何重新确定的。

我要问的问题的另一部分是我对这些帖子/答案发表的另一条评论。@SLott 说（有些措辞）

......我发现，private和protected是非常，非常重要的设计理念。但实际上，在成千上万的Java和Python行中，我从未真正使用过private或protected。...这是我的问题“受谁保护？

为了找出我的担忧是否值得关注，我对此发表了评论。在这里，进行编辑。

问：“不受谁保护？” 答：“来自想要访问变量和函数以便能够拒绝服务，访问敏感信息的恶意黑帽黑客……”看来这种A._no_touch = 5方法会使这种恶意编码员嘲笑我。 “请不要碰这个”。我A.__get_SSN(self)似乎只是希望，但愿BH（黑帽）不知道这个x = A(); x._A__get_SSN()窍门（@Zorf的窍门）。

我可能将问题放在错误的位置，如果是这样，我希望有人告诉我我将问题放在错误的位置，而且还要加以解释。^Q4基于类的方法是否有确保安全的方法？还有哪些其他非类和变量解决方案可用于处理Python ^Q5中的敏感数据？

这是一些代码，这些代码说明了为什么我将这些问题的答案视为怀疑是否应该将Python用于^第二季度敏感数据的原因。它不是完整的代码（为什么我要放下这些私有值和方法而不在任何地方使用它们？），但我希望它能显示出我想问的事情的类型。我在Python交互式控制台上输入并运行了所有这些程序。

## Type this into the interpreter to define the class.
class A():
  def __init__(self):
    self.name = "Nice guy."
    self.just_a_4 = 4
    self.my_number = 4
    self._this_needs_to_be_pi = 3.14
    self.__SSN = "I hope you do not hack this..."
    self.__bank_acct_num = 123
  def get_info():
    print("Name, SSN, bank account.")
  def change_my_number(self, another_num):
    self.my_number = another_num
  def _get_more_info(self):
    print("Address, health problems.")
  def send_private_info(self):
    print(self.name, self.__SSN, self.__bank_acct_num)
  def __give_20_bucks_to(self, ssn):
    self.__SSN += " has $20"
  def say_my_name(self):
    print("my name")
  def say_my_real_name(self):
    print(self.name)
  def __say_my_bank(self):
    print(str(self.__bank_acct_num))

>>> my_a = A()
>>> my_a._this_needs_to_be_pi
3.14
>>> my_a._this_needs_to_be_pi=4 # I just ignored begins-with-`_` 'rule'.
>>> my_a._this_needs_to_be_pi
4

## This next method could actually be setting up some kind of secure connection,  
## I guess, which could send the private data. I just print it, here.
>>> my_a.send_private_info()
Nice guy. I hope you do not hack this... 123

## Easy access and change a "private" variable
>>> my_a.__SSN
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute '__SSN'
>>> my_a.__dict__
{'name': 'Nice guy.', 'just_a_4': 4, 'my_number': 4, '_this_needs_to_be_pi': 4, 
'_A__SSN': 'I hope you do not hack this...', '_A__bank_acct_num': 123}
>>> my_a._A__SSN
'I hope you do not hack this...'

# (maybe) potentially more dangerous
>>> def give_me_your_money(self, bank_num):
      print("I don't know how to inject code, but I can")
      print("access you bank account number:")
      print(my_a._A__bank_acct_num)
      print("and use my bank account number:")
      print(bank_num)
>>> give_me_your_money(my_a,345)
I don't know how to inject code, but I can
access your bank account number:
123
and use my account number:
345

在这一点上，我重新输入了类定义，这可能不是必需的。

>>> this_a = A()
>>> this_a.__give_20_bucks_to('unnecessary param')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute '__give_20_bucks_to'
>>> this_a._A__give_20_bucks_to('unnecessary param')
>>> this_a._A__SSN
'I hope you do not hack this... has $20'

## Adding a fake "private" variable, `this_a.__SSN`
>>> this_a.__SSN = "B.H.'s SSN"
>>> this_a.__dict__
{'name': 'Nice guy.', 'just_a_4': 4, 'my_number': 4, '_this_needs_to_be_pi': 3.14, 
'_A__SSN': 'I hope you do not hack this... has $20', '_A__bank_acct_num': 123, 
'__SSN': "B.H.'s SSN"}
>>> this_a.__SSN
"B.H.'s SSN"

## Now, changing the real one and "sending/stealing the money"
>>> this_a._A__SSN = "B.H.'s SSN"
>>> this_a._A__give_20_bucks_to('unnecessary param')
>>> this_a._A__SSN
"B.H.'s SSN has $20"

我实际上是在以前的合同工作中使用敏感数据完成过一些工作-不是SSN和银行帐号，而是人们的年龄，地址，电话号码，个人历史，婚姻和其他关系历史，犯罪记录等。没有参与保护该数据的编程；我通过帮助对数据进行实证分析来为机器学习做准备，从而尝试提取有用的信息。我们有权使用这些数据并获得法律许可。另一个主要问题是：如何在Python中，可以一集，管理，分析，并得出有用的结论与此敏感数据^Q6？从我在这里讨论的内容来看，似乎类（或其他任何数据结构，我没有在这里讨论过，但它们似乎存在相同的问题）似乎不会允许安全地完成此操作（私人或受保护的方式。我想，基于类的解决方案可能有事情做与编译。这是真的^Q7？

最后，由于它不是安全性，而是代码的可靠性将我带到了这里，我将发表我发现的另一篇文章并发表评论以完成我的问题。

@Marcin 发布了，

[响应OP的话，“”问题很简单。我希望仅在类内部访问和更改私有变量。“ [Marcin回应]因此，请勿在类外部访问以开头的变量的代码__。使用pylint或类似方法捕获样式错误。

我的目标与我的答复如下的评论是，看看我的想法代表实际编码的担忧。我希望它不会显得粗鲁

如果您仅为自己的个人喜好编写代码，而不必将其交给其他人来维护，则此答案似乎很好。每当您处于协作编码环境（任何大专学历和/或工作经验）时，许多人都会使用该代码。有人希望使用一种简单的方法来更改__you_really_should_not_touch_this变量。他们这样做可能有充分的理由，但是您可能会设置代码，以使他们的“简便方法”破坏事情。

我的观点是否正确，还是大多数编码人员都尊重^Q8的双下划线？有没有更好的办法，使用Python，保护代码的完整性-比更好的__策略^Q9？

Answer 1

private并且protected出于安全考虑不存在。它们的存在是为了在您的代码内强制执行合同，即逻辑封装。如果将片段标记为protected或private，则表示它是实现类的逻辑实现细节，并且其他任何代码都不应直接接触它，因为其他代码可能[无法]正确使用它并可能弄乱状态。

例如，如果您的逻辑规则是每次更改self._a都必须同时更新self._b一定的值，那么您就不希望外部代码修改这些变量，因为如果外部代码不遵循此规则，内部状态可能会混乱。您只希望一个班级在内部处理此问题，因为这可以定位潜在的故障点。

最后，无论如何，所有这些都被编译成一大堆字节，并且所有数据都在运行时存储在内存中。那时，无论如何，在应用程序范围内都无法保护单个内存偏移量，而这仅仅是字节缓冲。protected并且private是程序员对自己的代码施加的约束，以保持自己的逻辑正确。为此，或多或少的非正式约定_就足够了。

攻击者无法在单个属性的级别上进行攻击。对于他们来说，正在运行的软件是一个黑匣子，无论内部发生什么都无所谓。如果攻击者可以实际访问各个内存偏移量，或者实际上可以注入代码，则无论哪种方式，这都非常有必要。protected并private在那时无关紧要。