如何使python脚本更好，面向对象?

Question

我正在开始我的Python和面向对象编程的冒险。

我写了一个用于加盐和散列密码的脚本。我的主要目标是使用 OOP 练习，而不是密码学。我知道没有错误处理。

想知道如何改进我的代码并使其更加面向对象。如果更有经验的人可以看看并给我一些建议如何让它变得更好，那就太好了。对新手的任何帮助都会很棒！

在我的代码下面，有简短的描述和问题。

问题：

I( 这两者之间的真正区别是什么？与和没有自我。X作品

def generate_new_salt(self, salt_ln=16):
self.new_salt = os.urandom(salt_ln)
print(f'new salt: {self.new_salt}')
return self.new_salt

和

def generate_new_salt(self, salt_ln=16):
new_salt = os.urandom(salt_ln)
print(f'new salt: {new_salt}')
return new_salt

II( 我在传递盐长度的默认值 (salt_ln = 16( 时遇到问题。对我来说，当它在每种方法中复制时看起来并不好。有没有办法让它更加全球化？

三(

描述：

该脚本在现实生活中并没有真正的用处。

第一部分：

哈希和盐密码，然后使用添加盐编码到 base64(将来比较哈希需要(。算法：base64(SHA256(密码+盐(+盐( Salt 是 X 个随机字节，其中可以指定 X，但默认情况下为 16。

第二部分(某种授权(：

将输入哈希(例如来自数据库(与来自输入纯密码的新创建哈希进行比较。 新的盐是从输入哈希中获取的盐创建的。

法典：

import base64
import hashlib
import os

class Hashing(object):
# base64( SHA256(password + salt) + salt)
# generate new salt (default 16 bytes)
def generate_new_salt(self, salt_ln=16):
self.new_salt = os.urandom(salt_ln)
print(f'new salt: {self.new_salt}')
return self.new_salt
# get salt from hash
def get_old_salt(self, input_hash, salt_ln=16):
self.old_salt = base64.b64decode(input_hash)[-salt_ln:]
print(f'old salt: {self.old_salt}')
return self.old_salt
# compute hash using parameters
def compute_hash(self, password, salt):
self.salt = salt
self.enc_password = password.encode()
# hashing SHA256(password + salt)
hash_object = hashlib.sha256(self.enc_password + salt)
# add salt to hash and encode to base64
hash_b64 = base64.b64encode(hash_object.digest() + salt)
print(f'new_hash: {hash_b64}')
return hash_b64
# create hash from new or old salt
def create_hash(self, password, salt_ln=16,old_salt=None):
if old_salt:    #if old salt then use it
self.salt = old_salt
else:           #else generate new salt
self.salt = Hashing().generate_new_salt(salt_ln)

hash = Hashing().compute_hash(password, self.salt)
return hash
# compare input hash with created using salt get from input
def compare_hashes(self, password, old_hash, salt_ln=16):
self.enc_password = password.encode()
#get salt from input hash
self.old_salt = Hashing().get_old_salt(old_hash, salt_ln)
#recreat input hash
re_hash = Hashing().create_hash(password,salt_ln, self.old_salt)
print(f'Compare: old_hash: {old_hash}')
print(f'Compare: new_hash: {re_hash}')
#compare
if re_hash.decode() == old_hash.decode():
return True
else:
return False

#code below is just for testing
NewSalt = Hashing().generate_new_salt()
Hash = Hashing().create_hash('pass')
OldSalt = Hashing().get_old_salt(Hash)
CompareHash = Hashing().compare_hashes('pass', Hash)
if CompareHash:
print('HASHES THE SAME')
else:
print('NOT THE SAME')
print(CompareHash)

Answer 1

尝试在类的__init__方法中设置默认值，然后可以编写方法以接受值或使用类的默认值

class Hashing(object):
def __init__(self, salt_ln):
self.default_salt_ln = salt_ln
# base64( SHA256(password + salt) + salt)
# generate new salt (default 16 bytes)
def generate_new_salt(self, salt_ln=None):
salt_ln = salt_ln or self.default_salt_ln
self.new_salt = os.urandom(salt_ln)
print(f'new salt: {self.new_salt}')
return self.new_salt

现在，您可以以任一方式调用方法：

Hashing(16).generate_new_salt()
Hashing(16).generate_new_salt(salt_ln=10)