自开发的哈希生成器（SHG）迎来 ULTRA 版本，内含新技术 SNF，详细介绍开发过程

 上链接：

GitHub项目地址/nitsc/Strong-Hash-Generator/tree/main/Ultra
**** 上的介绍/zwa20110606/article/details/140708538

 

**功能特点：**

**ULTRA 版本** 提供了以下功能：

- 使用了 10 层哈希算法：

  1. SHA3-256  

  2. SHA3-512

  3. SHA3-384

  4. SHA2-256

  5. SHA2-512

  6. SHA2-384

  7. BLAKE3

  8. BLAKE2b

  9. BLAKE2s

  10. RIPEMD-256

- 每层哈希算法都使用了很长的盐值（salt），以确保哈希值的唯一性和安全性。

- 采用新技术 `SNF(序列号因子)` ，使得破解难度大大增加，但数据验证需要采用注册数据时的设备（包括一样序列号的主板、CPU）。 

- 使用了多种密码哈希算法：

  1. bcrypt 

  2. PBKDF2

  3. Argon2

  4. HMAC-SHA256

  5. AES 中的 CBC 模式

- 4096 次迭代

- 动态活跃密钥 

 

详细深入了解

导入了一些库和模块，下面是每个库或模块的版本要求以及环境要求的详细信息：

1. **Python版本**:

   - Python 3.6或更高版本。部分库，如`cryptography`和`argon2`, 可能在Python 3.6及更高版本中才会有最佳兼容性和支持。

2. **第三方库**:

   - **`wmi`**: 用于Windows系统的WMI接口访问。要求Windows操作系统，Python版本至少为3.6。
   - **`hmac`**: Python标准库中的模块，无额外要求。
   - **`blake3`**: BLAKE3哈希库。可以通过`pip install blake3`安装，支持Python 3.6及以上版本。
   - **`hashlib`**: Python标准库中的模块，无额外要求。
   - **`platform`**: Python标准库中的模块，无额外要求。
   - **`subprocess`**: Python标准库中的模块，无额外要求。
   - **`Crypto`**: `pycryptodome`库中的模块。可以通过`pip install pycryptodome`安装，支持Python 3.6及以上版本。
   - **`argon2`**: Argon2密码哈希库。可以通过`pip install argon2-cffi`安装，支持Python 3.6及以上版本。
   - **`base64`**: Python标准库中的模块，无额外要求。
   - **`cryptography`**: 提供密码学操作的库。可以通过`pip install cryptography`安装，支持Python 3.6及以上版本。

确保你的Python环境中已经安装了这些第三方库的兼容版本，并且使用的Python版本与这些库兼容。如果有版本冲突，可以使用`pip`进行安装或升级。例如：

pip install blake3 pycryptodome argon2-cffi cryptography

（实际中pip安装命令只支持同时安装3个包）
或运行官方`安装依赖项.py`此外，确保你的操作系统和Python环境与这些库兼容，特别是在使用与系统相关的库（如`wmi`）时。

# 安装依赖




import os,subprocess



 




def up_pip():



    bat_folder = 'bat'




    if not (bat_folder):



        (bat_folder)



    



    bat_file_path = (bat_folder, '')



    with open(bat_file_path, 'w') as bat_file:



        bat_file.write("pip install --upgrade pip")



    ([bat_file_path], shell=True)



    




def install_package(package_name):



    bat_folder = 'bat'




    if not (bat_folder):



        (bat_folder)



    bat_file_path = (bat_folder, '')



    with open(bat_file_path, 'w') as bat_file:



        bat_file.write(f'pip install {package_name}')



    ([bat_file_path], shell=True)



    




def list():



    bat_folder = 'bat'




    if not (bat_folder):



        (bat_folder)



    bat_file_path = (bat_folder, '')



    with open(bat_file_path, 'w') as bat_file:



        bat_file.write("pip list")



    ([bat_file_path], shell=True)



 




def install_dependency():



    up_pip()



    install_package("bcrypt cryptography argon2-cffi")



    install_package("blake3 pycryptodome")



    list()



    print("安装依赖库成功！接下来您就可以正常使用 SHG Pre 啦")



    




if __name__ == "__main__":



    install_dependency()



 



 



# 导入必要的库




import os




import wmi




import hmac




import time




import blake3




import hashlib




import platform




import subprocess




from  import RIPEMD




from argon2 import PasswordHasher




from base64 import urlsafe_b64encode




from  import hashes




from  import default_backend




from .pbkdf2 import PBKDF2HMAC




from  import Cipher, algorithms, modes

 

 

# 哈希计算函数

本文档定义了一些用于计算哈希值的函数，这些函数使用不同的哈希算法，并结合了盐（salt）和设备序列号（device_sn）来生成唯一的哈希值。这些哈希算法包括SHA-2系列、SHA-3系列、BLAKE3、BLAKE2系列以及RIPEMD系列。

## 函数列表

### `generate_salt(length=1024)`
生成指定长度的随机盐值（salt）。
- **参数**:
  - `length` (int): 盐值的长度，默认为1024字节。
- **返回值**: 随机生成的盐值（bytes）。

### `salted_sha2256_hash(data, salt, sn)`
使用盐和SHA2-256算法计算哈希值。
- **参数**:
  - `data` (str): 要计算哈希的数据。
  - `salt` (bytes): 盐值。
  - `sn` (str): 设备序列号。
- **返回值**: 计算得到的SHA2-256哈希值（十六进制字符串）。

### `salted_sha2512_hash(data, salt, sn)`
使用盐和SHA2-512算法计算哈希值。
- **参数**:
  - `data` (str): 要计算哈希的数据。
  - `salt` (bytes): 盐值。
  - `sn` (str): 设备序列号。
- **返回值**: 计算得到的SHA2-512哈希值（十六进制字符串）。

### `salted_sha3256_hash(data, salt, sn)`
使用盐和SHA3-256算法计算哈希值。
- **参数**:
  - `data` (str): 要计算哈希的数据。
  - `salt` (bytes): 盐值。
  - `sn` (str): 设备序列号。
- **返回值**: 计算得到的SHA3-256哈希值（十六进制字符串）。

### `salted_sha3512_hash(data, salt, device_sn)`
使用盐和SHA3-512算法计算哈希值。
- **参数**:
  - `data` (str): 要计算哈希的数据。
  - `salt` (bytes): 盐值。
  - `device_sn` (str): 设备序列号。
- **返回值**: 计算得到的SHA3-512哈希值（十六进制字符串）。

### `salted_sha2384_hash(data, salt, device_sn)`
使用盐和SHA2-384算法计算哈希值。
- **参数**:
  - `data` (str): 要计算哈希的数据。
  - `salt` (bytes): 盐值。
  - `device_sn` (str): 设备序列号。
- **返回值**: 计算得到的SHA2-384哈希值（十六进制字符串）。

### `salted_sha3384_hash(data, salt, device_sn)`
使用盐和SHA3-384算法计算哈希值。
- **参数**:
  - `data` (str): 要计算哈希的数据。
  - `salt` (bytes): 盐值。
  - `device_sn` (str): 设备序列号。
- **返回值**: 计算得到的SHA3-384哈希值（十六进制字符串）。

### `salted_blake3_hash(data, salt, device_sn)`
使用盐和BLAKE3算法计算哈希值。
- **参数**:
  - `data` (str): 要计算哈希的数据。
  - `salt` (bytes): 盐值。
  - `device_sn` (str): 设备序列号。
- **返回值**: 计算得到的BLAKE3哈希值（十六进制字符串）。

### `salted_blake2b_hash(data, salt, device_sn)`
使用盐和BLAKE2b算法计算哈希值。
- **参数**:
  - `data` (str): 要计算哈希的数据。
  - `salt` (bytes): 盐值。
  - `device_sn` (str): 设备序列号。
- **返回值**: 计算得到的BLAKE2b哈希值（十六进制字符串）。

### `salted_blake2s_hash(data, salt, device_sn)`
使用盐和BLAKE2s算法计算哈希值。
- **参数**:
  - `data` (str): 要计算哈希的数据。
  - `salt` (bytes): 盐值。
  - `device_sn` (str): 设备序列号。
- **返回值**: 计算得到的BLAKE2s哈希值（十六进制字符串）。

### `salted_pipemd256_hash(data, salt, device_sn)`
使用盐和RIPEMD-160算法计算哈希值。
- **参数**:
  - `data` (str): 要计算哈希的数据。
  - `salt` (bytes): 盐值。
  - `device_sn` (str): 设备序列号。
- **返回值**: 计算得到的RIPEMD-160哈希值（十六进制字符串）。

# 生成盐（Salt）




def generate_salt(length=1024):



    return (length)



 



# 使用盐和 SHA2-256 计算哈希值




def salted_sha2256_hash(data, salt, sn):



    sha2256 = hashlib.sha256()



    (salt + ('utf-8') + ('utf-8'))



    return ()



 



# 使用盐和 SHA2-512 计算哈希值




def salted_sha2512_hash(data, salt, sn):



    sha2512 = hashlib.sha512()



    (salt + ('utf-8') + ('utf-8'))



    return ()



 



# 使用盐和 SHA3-256 计算哈希值




def salted_sha3256_hash(data, salt, sn):



    sha3256 = hashlib.sha3_256()



    (salt + ('utf-8') + ('utf-8'))



    return ()



 



# 使用盐和 SHA3-512 计算哈希值




def salted_sha3512_hash(data, salt, device_sn):



    sha3512 = hashlib.sha3_512()



    (salt + device_sn.encode('utf-8') + ('utf-8'))



    return ()



 



# 使用盐和 SHA2-384 计算哈希值




def salted_sha2384_hash(data, salt, device_sn):



    sha2384 = hashlib.sha384()



    (salt + device_sn.encode('utf-8') + ('utf-8'))



    return ()



 



# 使用盐和 SHA3-384 计算哈希值




def salted_sha3384_hash(data, salt, device_sn):



    sha3384 = hashlib.sha3_384()



    (salt + device_sn.encode('utf-8') + ('utf-8'))



    return ()



 



# 使用盐和 BLAKE3 计算哈希值




def salted_blake3_hash(data, salt, device_sn):



    return blake3.blake3(salt + device_sn.encode('utf-8') + ('utf-8')).hexdigest()



 



# 使用盐和 BLAKE2b 计算哈希值




def salted_blake2b_hash(data, salt, device_sn):



    blake2b = hashlib.blake2b()



    (salt + device_sn.encode('utf-8') + ('utf-8'))



    return ()



 



# 使用盐和 BLAKE2s 计算哈希值




def salted_blake2s_hash(data, salt, device_sn):



    blake2s = hashlib.blake2s()



    (salt + device_sn.encode('utf-8') + ('utf-8'))



    return ()



 



# 使用盐和 PIPEMD 计算哈希值




def salted_pipemd256_hash(data, salt, device_sn):



    hasher = ()



    (salt + device_sn.encode('utf-8') + ('utf-8'))



    return ()

 

 

# 设备信息获取和哈希计算

本文档定义了一个用于获取设备信息并计算设备哈希值的类和函数。

## `Hardware` 类

### 方法列表

#### `get_cpu_sn()`
获取CPU序列号。
- **返回值**: CPU的序列号（字符串）。

#### `get_baseboard_sn()`
获取主板序列号。
- **返回值**: 主板的序列号（字符串）。

#### `get_serial()`
获取设备序列号。
- **返回值**: 设备的网络主机名（字符串）。

## `con()` 函数

该函数获取设备的CPU序列号、主板序列号和设备序列号，并将它们拼接成一个字符串。然后，生成一个盐值，并使用SHA3-512算法计算哈希值。

# 获取设备信息




class Hardware:



    # 获取 CPU 序列号




    @staticmethod




    def get_cpu_sn():



        c = ()



        for cpu in c.Win32_Processor():



            # print(())




            return ()



 



    # 获取主板序列号




    @staticmethod




    def get_baseboard_sn():



        c = ()



        for board_id in c.Win32_BaseBoard():



            # print(board_id.SerialNumber)




            return board_id.SerialNumber



 



    # 获取设备序列号




    @staticmethod




    def get_serial():



        return () 



 




def con():



    cpusn = Hardware.get_cpu_sn()



    boardsn = Hardware.get_baseboard_sn()



    serial = Hardware.get_serial()



    device_sn = cpusn + boardsn + serial



    salt = generate_salt()



    device_sn = salted_sha3512_hash(device_sn, salt, device_sn)



    return device_sn

 

 

 

# 哈希、密钥衍生和加密函数

本文档定义了几个用于计算哈希值、密钥衍生、数据加密以及生成HMAC的函数。

## 函数列表

### `argon2_hash(data)`
使用Argon2算法计算数据的哈希值。
- **参数**:
  - `data` (str): 要计算哈希的输入数据。
- **返回值**: 计算得到的Argon2哈希值（字符串）。

### `pbkdf2_hash(data, salt)`
使用PBKDF2算法进行密钥衍生。
- **参数**:
  - `data` (str): 要衍生的输入数据。
  - `salt` (bytes): 盐值。
- **返回值**: 计算得到的密钥（Base64编码的字符串）。

### `generate_key(password: str, salt: bytes)`
生成随机密钥，使用PBKDF2算法进行密钥衍生。
- **参数**:
  - `password` (str): 用于生成密钥的密码。
  - `salt` (bytes): 盐值。
- **返回值**: 生成的密钥（字节串）。

### `encrypt(data: bytes, key: bytes)`
使用AES算法对数据进行加密。
- **参数**:
  - `data` (bytes): 要加密的数据。
  - `key` (bytes): 用于加密的密钥。
- **返回值**: 加密后的数据（包括初始向量和加密结果，字节串）。

### `create_hmac(data: bytes, key: bytes)`
生成数据的HMAC值。
- **参数**:
  - `data` (bytes): 要生成HMAC的数据。
  - `key` (bytes): 用于生成HMAC的密钥。
- **返回值**: 生成的HMAC值（字节串）。

# 通过 Argon2 计算哈希值




def argon2_hash(data):



    ph = PasswordHasher()



    hashed = ph.hash(data)



    return hashed



 



# 使用 PBKDF2 进行密钥衍生




def pbkdf2_hash(data, salt):



    kdf = PBKDF2HMAC(



        algorithm=hashes.SHA256(),



        length=1024,



        salt=salt,



        iterations=66536,



        backend=default_backend()



    )



    key = (('utf-8'))



    return urlsafe_b64encode(key).decode('utf-8')



 



# 生成随机密钥




def generate_key(password: str, salt: bytes):



    kdf = PBKDF2HMAC(



        algorithm=hashes.SHA256(),



        length=32,



        salt=salt,



        iterations=66536,



        backend=default_backend()



    )



    return (())



 



# 加密数据




def encrypt(data: bytes, key: bytes):



    iv = (16)



    cipher = Cipher((key), (iv), backend=default_backend())



    encryptor = ()



    return iv + (data) + ()



 



# 生成 HMAC




def create_hmac(data: bytes, key: bytes):



    return (key, data, hashlib.sha256).digest()

 

 

 

# 综合哈希计算和加密函数

本文档定义了两个用于进行复杂哈希计算和加密操作的函数：`strong_hash` 和 `cycle_strong_hash`。

## `strong_hash(data, salt)`

进行多层哈希计算和AES加密。
- **步骤**:
  1. 获取设备信息（通过调用 `con()` 函数）。
  2. 使用盐化后的SHA2-256算法计算初始哈希值。
  3. 使用SHA2-256的结果计算盐化后的SHA2-512哈希值。
  4. 使用SHA2-512的结果计算盐化后的SHA3-256哈希值。
  5. 使用SHA3-256的结果计算盐化后的SHA3-512哈希值。
  6. 使用SHA3-512的结果计算盐化后的SHA2-384哈希值。
  7. 使用SHA2-384的结果计算盐化后的SHA3-384哈希值。
  8. 使用SHA3-384的结果计算盐化后的BLAKE3哈希值。
  9. 使用BLAKE3的结果计算盐化后的BLAKE2b哈希值。
  10. 使用BLAKE2b的结果计算盐化后的BLAKE2s哈希值。
  11. 使用BLAKE2s的结果计算盐化后的RIPEMD-160哈希值。
  12. 使用AES算法（CFB模式）对RIPEMD-160哈希值进行加密。
  13. 使用HMAC-SHA256计算加密后的哈希值的HMAC值。
  14. 使用HMAC-SHA256的结果计算盐化后的Argon2哈希值。
  15. 使用Argon2的结果计算盐化后的PBKDF2哈希值。
- **参数**:
  - `data` (str): 要计算哈希的数据。
  - `salt` (bytes): 盐值。
- **返回值**: 计算得到的PBKDF2哈希值（Base64编码的字符串）。 

## `cycle_strong_hash(data, iterations=1024)`

进行多次哈希计算，使用 `strong_hash` 函数。
- **步骤**:
  1. 生成盐值（调用 `generate_salt()` 函数）。
  2. 循环执行 `strong_hash` 函数 `iterations` 次。
- **参数**:
  - `data` (str): 要计算哈希的数据。
  - `iterations` (int): 哈希计算的次数，默认为1024。
- **返回值**: 最终计算得到的哈希值（Base64编码的字符串）。

# 综合使用 10层算法 和 AES加密算法 等进行哈希计算




def strong_hash(data, salt):



    # 获取设备信息




    device_sn = con()



    



    # 先计算盐化后的 SHA2-256 哈希值




    sha2256_value = salted_sha2256_hash(data, salt, device_sn)



    



    # 使用 SHA2-256 的结果计算盐化后的 SHA2-512 哈希值




    sha2512_value = salted_sha2512_hash(sha2256_value, salt, device_sn)



    



    # 使用 SHA2-512 的结果计算盐化后的 SHA3-256 哈希值




    sha3256_value = salted_sha3256_hash(sha2512_value, salt, device_sn)



    



    # 使用 SHA3-256 的结果计算盐化后的 SHA3-512 哈希值




    sha3512_value = salted_sha3512_hash(sha3256_value, salt, device_sn)



    



    # 使用 SHA3-512 的结果计算盐化后的 SHA2-384 哈希值




    sha2384_value = salted_sha2384_hash(sha3512_value, salt, device_sn)



    



    # 使用 SHA2-384 的结果计算盐化后的 SHA3-384 哈希值




    sha3384_value = salted_sha3384_hash(sha2384_value, salt, device_sn)



    



    # 使用 SHA3-384 的结果计算盐化后的 BLAKE3 哈希值




    blake3_value = salted_blake3_hash(sha3384_value, salt, device_sn)



    



    # 使用 BLAKE3 的结果计算盐化后的 BLAKE2b 哈希值




    blake2b_value = salted_blake2b_hash(blake3_value, salt, device_sn)



    



    # 使用 BLAKE2b 的结果计算盐化后的 BLAKE2s 哈希值




    blake2s_value = salted_blake2s_hash(blake2b_value, salt, device_sn)



    



    # 使用 BLAKE2s 的结果计算盐化后的 PIPEMD 哈希值




    pipemd256_value = salted_pipemd256_hash(blake2s_value, salt, device_sn)



    



    # 使用 AES 加密算法的 CFB 模式加密 PIPEMD 哈希值




    password = sha3512_value + blake3_value



    key = generate_key(password, salt)



    encrypted_hash = encrypt(pipemd256_value.encode(), key)



    



    # 使用 HMAC-SHA256 计算加密后的哈希值的 HMAC 值




    hmac_value = create_hmac(encrypted_hash, key)



    



    # 使用 HMAC-SHA256 的结果计算盐化后的 Argon2 哈希值




    global then_value



    then_value = urlsafe_b64encode(hmac_value).decode()



    argon2_hash_value = argon2_hash(then_value)



    



    # 使用 Argon2 的结果计算盐化后的 PBKDF2 哈希值




    final_hash_value = pbkdf2_hash(argon2_hash_value, salt)



    return final_hash_value



 



# 循环计算 哈希值




def cycle_strong_hash(data, iterations=4096):



    salt = generate_salt()  # 生成盐




    



    # 循环多次哈希计算




    for _ in range(iterations):



        end_hash_value = strong_hash(data, salt)



    return end_hash_value  # 返回最终的哈希值

 

 

 

 

# 主函数

`main`函数是程序的入口点，用于展示一个强哈希生成器的简要预览，并允许用户输入数据进行哈希计算。

## 功能描述

1. **介绍**:
   - 输出程序的标题和退出提示信息。2. **循环**:
   - 提示用户输入要计算哈希的数据。
   - 如果用户输入`!@exit`或`！@exit`，则退出程序。
   - 否则，尝试计算输入数据的哈希值。
     - 记录开始时间。
     - 调用 `cycle_strong_hash` 函数进行哈希计算（`iterations` 参数设置为1）。
     - 记录结束时间并输出计算得到的哈希值和所花费的时间。
     - 捕获并处理可能出现的异常，输出错误信息。

# 主函数




def main():



    # 介绍




    print("Super Strong Hash Generator Preview ")



    print("\nEnter '!@exit' to quit.")



    



    # 循环




    while True:



        d = input("Enter the data to hash: ")



        d = ()



        if d == '!@exit' or d == '！@exit':



            break




        else:



            try:



                # 调用 cycle_strong_hash 函数计算哈希值




                start_time = ()  # 记录开始时间




                super_hash_value = cycle_strong_hash(d, iterations=1)



                end_time = ()  # 记录结束时间




                print("Super Strong Hash:", super_hash_value)



                print("Time taken to compute hash:", end_time - start_time, "seconds")



            except Exception as e:



                print("Error:", e)



 



# 运行主函数




if __name__ == "__main__": 



    main()

 

 

 

我的个人网站

我的个人网站/

我的GitHub个人主页

我的GitHub主页，有很多开源实用的程序/nitsc

 图来自GitHub Octodex，侵权删