gomyck-tools 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

ctools/resource_bundle_tools.py

@@ -0,0 +1,121 @@
+import hashlib
+import io
+import json
+import os
+import shutil
+import zipfile
+from base64 import b64decode
+from base64 import b64encode
+
+from Crypto.Hash import MD5
+from Crypto.PublicKey import RSA
+from Crypto.Signature import pkcs1_15
+
+from ctools import sys_log, work_path, application
+
+log = sys_log.flog
+
+
+def data_layout(manifest: dict):
+  """
+  数据重新排版
+  :param manifest:
+  :return:
+  """
+  data = ""
+  for key in sorted(manifest):
+    if key != "signature":
+      data += "%s=%s," % (key, manifest[key])
+  return data[:-1]
+
+
+def get_md5_sum(data):
+  return hashlib.md5(data + "gomyck-daning".encode()).hexdigest()
+
+
+def signature(manifest: dict):
+  """
+  定义签名函数，能够使用指定的私钥对数据文件进行签名，并将签名结果输出到文件返回
+  :param manifest: 元数据字典
+  :return:
+  """
+  with open(work_path.get_app_path() + '/keys/resource_private_key.pem', 'r') as pri:
+    private_key = RSA.import_key(pri.read())
+    digest = MD5.new(data_layout(manifest).encode('utf-8'))
+    return b64encode(pkcs1_15.new(private_key).sign(digest)).decode()
+
+
+def sign_verify(manifest: dict, sign_val: str):
+  """
+  定义签名验证函数，能够使用指定的公钥对任务2中的签名文件进行验证，返回验证结果
+  :param manifest: 元数据字典
+  :param sign_val: 对比的签名值
+  :return:
+  """
+  with open(work_path.get_app_path() + '/keys/resource_public_key.pem', 'r') as pub:
+    public_key = RSA.import_key(pub.read())
+    digest = MD5.new(data_layout(manifest).encode('utf-8'))
+    try:
+      pkcs1_15.new(public_key).verify(digest, b64decode(sign_val))
+      return True
+    except:
+      return False
+
+
+def unpack_resource(resource_name, file):
+  """
+  解压资源包并验证包的完整性和签名
+  :param resource_name:
+  :param file:
+  :return:
+  """
+  message = None
+  file_md5_sum = os.path.splitext(resource_name)[0].split('-')[-1]
+  if file_md5_sum != get_md5_sum(file.read()):
+    message = "资源包已损坏, 请重新打包"
+  else:
+    manifest = {}
+    with zipfile.ZipFile(file, 'r') as zf:
+      for file in zf.filelist:
+        if file.filename == "manifest.json":
+          manifest = json.loads(zf.read(file.filename))
+          break
+      # 校验签名
+      if sign_verify(manifest, manifest.get('signature')):
+        resource_path = os.path.join(application.Upload.source_pkg_path, manifest['name'])
+        shutil.rmtree(resource_path, ignore_errors=True)
+        zf.extractall(resource_path)
+      else:
+        message = "资源包签名校验未通过"
+  return message
+
+
+def pack_resource(resource_path):
+  """
+  压缩打包资源包为zip文件
+  :param resource_path:
+  :return:
+  """
+  file_name = None
+  buffer = io.BytesIO()
+  manifest_path = os.path.join(resource_path, 'manifest.json')
+  if os.path.exists(manifest_path):
+    resource_name = os.path.split(resource_path)[-1]
+    with open(manifest_path, mode="r", encoding='utf-8') as f:
+      manifest = json.loads(f.read())
+      manifest["signature"] = signature(manifest)
+    with open(manifest_path, mode="w", encoding='utf-8') as f:
+      f.write(json.dumps(manifest, indent=2, ensure_ascii=False))
+
+    with zipfile.ZipFile(buffer, 'w', zipfile.ZIP_DEFLATED, allowZip64=False) as zf:
+      for dir_path, dir_names, file_names in os.walk(resource_path):
+        for filename in file_names:
+          filepath = os.path.join(dir_path, filename)
+          arcname = os.path.join(dir_path.split(resource_name)[-1], filename)
+          zf.write(filepath, arcname=arcname)
+    buffer.seek(0)
+    md5_sum = get_md5_sum(buffer.getvalue())
+    file_name = "%s-%s.zip" % (resource_name, md5_sum)
+  else:
+    log.info("资源包%s不存在manifest.json元数据文件， 无法打包" % resource_path)
+  return file_name, buffer

ctools/rsa.py

@@ -0,0 +1,70 @@
+import base64
+
+from Crypto.Cipher import PKCS1_OAEP
+from Crypto.PublicKey import RSA
+from Crypto.Signature import pkcs1_15
+from Crypto.Hash import SHA256
+
+from ctools import work_path, cjson
+
+ENCRYPT_CHUNK_SIZE = 245
+decrypt_CHUNK_SIZE = 512
+
+def generate_rsa_keypair(bits=2048):
+  key = RSA.generate(bits)
+  private_key = key.export_key()  # 导出私钥
+  public_key = key.publickey().export_key()  # 导出公钥
+  with open("private_key.pem", "wb") as f:
+    f.write(private_key)
+  with open("public_key.pem", "wb") as f:
+    f.write(public_key)
+
+def loadLicenseInfo(auth_code):
+  with open(work_path.get_app_path() + '/keys/license.key', 'r') as pri:
+    decrypt_message = decrypt(auth_code.strip(), pri.read())
+    return cjson.loads(decrypt_message)
+
+# 加密函数
+def encrypt(msg, public_key):
+  parts = b''
+  public_key = RSA.import_key(public_key)
+  cipher = PKCS1_OAEP.new(public_key)
+  for i in range(0, len(msg), ENCRYPT_CHUNK_SIZE):
+    parts += cipher.encrypt(msg[i:i + ENCRYPT_CHUNK_SIZE].encode())
+  encrypted_base64 = base64.b64encode(parts)
+  return encrypted_base64.decode()
+
+# 解密函数
+def decrypt(msg, private_key):
+  parts = b''
+  public_key = RSA.import_key(private_key)
+  cipher = PKCS1_OAEP.new(public_key)
+  encrypted_bytes = base64.b64decode(msg)
+  for i in range(0, len(encrypted_bytes), decrypt_CHUNK_SIZE):
+    parts += cipher.decrypt(encrypted_bytes[i:i + decrypt_CHUNK_SIZE])
+  return parts.decode()
+
+# 验签
+def verify_sign(msg, public_key, sign):
+  public_key = RSA.import_key(public_key)
+  hash_message = SHA256.new(msg.encode())
+  try:
+    pkcs1_15.new(public_key).verify(hash_message, base64.b64decode(sign.encode()))
+    return True
+  except Exception as e:
+    print('签名验证失败: {}'.format(e))
+    return False
+
+# 签名
+def sign_msg(msg, private_key):
+  private_key = RSA.import_key(private_key)
+  hash_message = SHA256.new(msg.encode())
+  signature = pkcs1_15.new(private_key).sign(hash_message)
+  return base64.b64encode(signature).decode()
+
+
+# with open(work_path.get_current_path() + '/private_key.pem', 'r') as key:
+#   key = key.read()
+#   sign = sign_msg(key, key)
+#   with open(work_path.get_current_path() + '/public_key.pem', 'r') as pub:
+#     print(verify_sign(key, pub.read(), sign+'123'))

ctools/screenshot_tools.py

@@ -0,0 +1,127 @@
+import os
+import time
+import tkinter as tk
+
+import pyautogui
+
+from ctools import application, string_tools
+
+"""
+截屏工具类, 按回车截图
+image_path=screenshot_tools.screenshot()
+"""
+
+
+class ScreenshotTools:
+  def __init__(self):
+    self.root = tk.Tk()
+    self.root.overrideredirect(True)
+    self.root.attributes("-alpha", 0.1)
+    self.root.attributes('-topmost', 'true')
+    self.root.geometry("{0}x{1}+0+0".format(self.root.winfo_screenwidth(), self.root.winfo_screenheight()))
+    self.root.configure(bg="black")
+
+    self.canvas = tk.Canvas(self.root)
+    self.canvas.bind("<Button-3>", self.change_center_point)
+
+    self.x, self.y = 0, 0
+    self.xstart, self.ystart = 0, 0
+    self.xend, self.yend = 0, 0
+    self.xcenter, self.ycenter = 0, 0
+
+    self.select_area = self.canvas.create_rectangle(0, 0, 0, 0, outline='red', width=0, dash=(4, 4))
+    self.screenshot_path = None
+    self.center_offset = (0, 0)
+
+    self.pos_div = tk.Toplevel(self.root)
+    self.pos_div.overrideredirect(True)
+    self.pos_div.attributes('-topmost', 'true')
+    self.pos_div.configure(bg="grey")
+    self.pos_div.geometry("360x25")
+
+    self.pos_div_text = "POS: (%s, %s), Enter键-截图, Esc键-退出, 右键设置点击位置"
+    self.pos_label = tk.Label(self.pos_div, text=self.pos_div_text % (0, 0), bg="black", fg="white")
+    self.pos_label.pack(fill="both", expand=True)
+
+    self.center_div = None
+
+    self.root.bind('<Escape>', self.sys_out)  # 键盘Esc键->退出
+    self.root.bind('<Motion>', self.print_pos)
+    self.root.bind("<Button-1>", self.mouse_left_down)  # 鼠标左键点击->显示子窗口
+    self.root.bind("<B1-Motion>", self.mouse_left_move)  # 鼠标左键移动->改变子窗口大小
+    self.root.bind("<ButtonRelease-1>", self.mouse_left_up)  # 鼠标左键释放->记录最后光标的位置
+    self.root.bind("<Return>", self.save_image)  # 回车键->截屏并保存图片
+    self.root.focus()
+
+  def start(self):
+    self.root.mainloop()
+
+  def print_pos(self, event):
+    self.x, self.y = event.widget.winfo_pointerxy()
+    self.pos_label.config(text=self.pos_div_text % (self.x, self.y))
+    self.pos_div.geometry(f"+{self.x + 10}+{self.y + 10}")
+
+  def change_center_point(self, event):
+    offset_x = event.x + self.xstart - self.xcenter - 2
+    offset_y = event.y + self.ystart - self.ycenter - 2
+    self.center_div.geometry(f"+{self.xstart+event.x-2}+{self.ystart+event.y-2}")
+    self.center_offset = (offset_x, offset_y)
+
+  def mouse_left_down(self, event):
+    if self.center_div is None:
+      self.center_div = tk.Toplevel(self.root)
+      self.center_div.overrideredirect(True)
+      self.center_div.attributes('-topmost', 'true')
+      self.center_div.configure(bg="red")
+      self.center_div.geometry("4x4")
+
+    self.x, self.y = event.x, event.y
+    self.xstart, self.ystart = event.x, event.y
+    self.canvas.configure(height=1)
+    self.canvas.configure(width=1)
+    self.canvas.config(highlightthickness=0)  # 无边框
+    self.canvas.place(x=event.x, y=event.y)
+    self.center_div.geometry(f"+{self.xstart}+{self.ystart}")
+
+  def mouse_left_move(self, event):
+    self.x, self.y = event.x, event.y
+    self.xcenter = self.xstart + int((self.x-self.xstart)/2)-2
+    self.ycenter = self.ystart + int((self.y-self.ystart)/2)-2
+
+    self.pos_label.config(text=self.pos_div_text % (self.x, self.y))
+    self.pos_div.geometry(f"+{self.x + 10}+{self.y + 10}")
+    self.center_div.geometry(f"+{self.xcenter}+{self.ycenter}")
+
+    self.canvas.configure(height=event.y - self.ystart)
+    self.canvas.configure(width=event.x - self.xstart)
+    self.canvas.coords(self.select_area, 0, 0, event.x - self.xstart, event.y - self.ystart)
+
+  def mouse_left_up(self, event):
+    self.xend, self.yend = event.x, event.y
+
+  def save_image(self, event):
+    try:
+      self.canvas.delete(self.select_area)
+      self.canvas.place_forget()
+      self.sys_out()
+
+      time.sleep(0.3)
+      img = pyautogui.screenshot(region=[self.xstart, self.ystart, self.xend - self.xstart, self.yend - self.ystart])
+      self.screenshot_path = os.path.join(application.Server.screenshotPath,
+                                          "screenshot-%s.png" % string_tools.get_snowflake_id())
+      img.save(self.screenshot_path)
+    except Exception:
+      pass
+
+  def sys_out(self, event=None):
+    if self.center_div:
+      self.center_div.destroy()
+    self.pos_div.destroy()
+    self.root.destroy()
+
+
+def screenshot():
+  st = ScreenshotTools()
+  st.start()
+  return st.screenshot_path, st.center_offset
+

ctools/sign.py

@@ -0,0 +1,20 @@
+import hashlib
+import hmac
+
+global_key = 'gomyck2014'
+
+
+def generate_signature(file_path, key: str = global_key):
+  try:
+    with open(file_path, 'rb') as f:
+      file_contents = f.read()
+      file_hash = hashlib.sha256(file_contents).digest()
+    sign_val = hmac.new(key.encode(), file_hash, hashlib.sha256).digest()
+    return sign_val.hex()
+  except:
+    return ''
+
+def digest(value: str, key: str = global_key):
+  val_hash = hashlib.sha256(value.encode()).digest()
+  sign_val = hmac.new(key.encode(), val_hash, hashlib.sha256).digest()
+  return sign_val.hex()

ctools/sm_tools.py

@@ -0,0 +1,49 @@
+import base64
+
+from gmssl import sm2
+from gmssl.sm4 import CryptSM4, SM4_ENCRYPT, SM4_DECRYPT
+
+sm2_crypt: sm2.CryptSM2 = None
+
+def init(private_key: str, public_key: str):
+  global sm2_crypt
+  if sm2_crypt is not None:
+    print('sm2 is already init!!!')
+    return
+  sm2_crypt = sm2.CryptSM2(private_key=private_key, public_key=public_key, asn1=True, mode=1)
+
+def sign_with_sm2(sign_data: str) -> str:
+  if sm2_crypt is None: raise Exception('sm2 is not init!!!')
+  return sm2_crypt.sign_with_sm3(sign_data.encode('UTF-8'))
+
+
+def verify_with_sm2(sign_val: str, sign_data: str) -> bool:
+  if sm2_crypt is None: raise Exception('sm2 is not init!!!')
+  try:
+    return sm2_crypt.verify_with_sm3(sign_val, sign_data.encode('UTF-8'))
+  except Exception as e:
+    print('签名验证失败: {}'.format(e))
+    return False
+
+def encrypt_with_sm2(encrypt_data: str) -> str:
+  if sm2_crypt is None: raise Exception('sm2 is not init!!!')
+  return base64.b64encode(sm2_crypt.encrypt(encrypt_data.encode('UTF-8'))).decode('UTF-8')
+
+
+def decrypt_with_sm2(encrypt_data: str) -> str:
+  if sm2_crypt is None: raise Exception('sm2 is not init!!!')
+  return sm2_crypt.decrypt(base64.b64decode(encrypt_data.encode('UTF-8'))).decode('UTF-8')
+
+
+def encrypt_with_sm4(key: bytes, encrypt_text: str):
+  crypt_sm4 = CryptSM4()
+  crypt_sm4.set_key(key, SM4_ENCRYPT)
+  encrypt_value = base64.b64encode(crypt_sm4.crypt_ecb(encrypt_text.encode()))
+  return encrypt_value.decode()
+
+
+def decrypt_with_sm4(key: bytes, decrypt_text: str):
+  crypt_sm4 = CryptSM4()
+  crypt_sm4.set_key(key, SM4_DECRYPT)
+  decrypt_value = crypt_sm4.crypt_ecb(base64.b64decode(decrypt_text))
+  return decrypt_value.decode()

ctools/snow_id.py

@@ -0,0 +1,76 @@
+import time
+
+# 64位ID的划分
+WORKER_ID_BITS = 5
+DATACENTER_ID_BITS = 5
+SEQUENCE_BITS = 12
+# 最大取值计算
+MAX_WORKER_ID = -1 ^ (-1 << WORKER_ID_BITS)  # 2**5-1 0b11111
+MAX_DATACENTER_ID = -1 ^ (-1 << DATACENTER_ID_BITS)
+# 移位偏移计算
+WOKER_ID_SHIFT = SEQUENCE_BITS
+DATACENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS
+TIMESTAMP_LEFT_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATACENTER_ID_BITS
+# 序号循环掩码
+SEQUENCE_MASK = -1 ^ (-1 << SEQUENCE_BITS)
+# Twitter元年时间戳
+TWEPOCH = 1288834974657
+
+class SnowId(object):
+  """
+  用于生成IDs
+  """
+  def __init__(self, datacenter_id=0, worker_id=0, sequence=0):
+    """
+    初始化
+    :param datacenter_id: 数据中心（机器区域）ID
+    :param worker_id: 机器ID
+    :param sequence: 起始序号
+    """
+    # sanity check
+    if worker_id > MAX_WORKER_ID or worker_id < 0:
+      raise ValueError('worker_id值越界')
+    if datacenter_id > MAX_DATACENTER_ID or datacenter_id < 0:
+      raise ValueError('datacenter_id值越界')
+    self.worker_id = worker_id
+    self.datacenter_id = datacenter_id
+    self.sequence = sequence
+    self.last_timestamp = -1  # 上次计算的时间戳
+
+  @staticmethod
+  def _gen_timestamp():
+    """
+    生成整数时间戳
+    :return:int timestamp
+    """
+    return int(time.time() * 1000)
+
+  def get_id(self):
+    """
+    获取新ID
+    :return:
+    """
+    timestamp = self._gen_timestamp()
+    # 时钟回拨
+    if timestamp < self.last_timestamp:
+      print('clock is moving backwards. Rejecting requests until {}'.format(self.last_timestamp))
+      raise
+    if timestamp == self.last_timestamp:
+      self.sequence = (self.sequence + 1) & SEQUENCE_MASK
+      if self.sequence == 0:
+        timestamp = self._til_next_millis(self.last_timestamp)
+    else:
+      self.sequence = 0
+    self.last_timestamp = timestamp
+    new_id = ((timestamp - TWEPOCH) << TIMESTAMP_LEFT_SHIFT) | (self.datacenter_id << DATACENTER_ID_SHIFT) | \
+             (self.worker_id << WOKER_ID_SHIFT) | self.sequence
+    return new_id
+
+  def _til_next_millis(self, last_timestamp):
+    """
+    等到下一毫秒
+    """
+    timestamp = self._gen_timestamp()
+    while timestamp <= last_timestamp:
+      timestamp = self._gen_timestamp()
+    return timestamp

ctools/str_diff.py

@@ -0,0 +1,20 @@
+# import difflib
+#
+# s1 = '12-23'
+# s2 = '00-11'
+# s3 = '2023-05-05 12:00:00-2023-05-06 23:00:00 剩余4'
+#
+# sm = difflib.SequenceMatcher(None, s1, s3)
+#
+# print(sm.ratio()) # 输出相似度得分
+
+
+from fuzzywuzzy import fuzz
+
+s1 = '12-23'
+s2 = '00-11'
+s3 = '2023-05-05 12:00:00-2023-05-06 23:00:00 剩余4'
+s4 = '2023-04-28 00:00:00-2023-04-28 11:00:00 剩余12'
+score = fuzz.ratio(s2, s4)
+
+print(score) # 输出相似度得

ctools/string_tools.py

@@ -0,0 +1,85 @@
+from ctools.snow_id import SnowId
+
+idWorker = SnowId(1, 2, 0)
+
+def get_random_str(size: int = 10) -> str:
+  import random
+  return "".join(random.sample('abcdefghjklmnpqrstuvwxyz123456789', size))
+
+def get_uuid() -> str:
+  import uuid
+  return str(uuid.uuid1()).replace("-", "")
+
+def get_snowflake_id():
+  return idWorker.get_id()
+
+def decode_bytes(bytes_str):
+  import chardet
+  res_str = ""
+  if bytes_str:
+    detect = chardet.detect(bytes_str)
+    if detect:
+      confidence = 0
+      chardet_error = False
+      try:
+        confidence = float(detect.get('confidence'))
+        res_str = bytes_str.decode(encoding=detect.get('encoding'))
+      except Exception:
+        chardet_error = True
+
+      try:
+        if confidence <= 0.95 or chardet_error:
+          encoding = "utf-8" if detect.get('encoding') == "utf-8" else "gbk"
+          res_str = bytes_str.decode(encoding=encoding)
+      except Exception:
+        res_str = str(bytes_str)
+  return res_str
+
+
+def check_sum(content: str):
+  import hashlib
+  try:
+    algorithm = hashlib.sha256()
+    algorithm.update(content.encode())
+    return algorithm.hexdigest()
+  except Exception:
+    return None
+
+
+def is_list(v: str):
+  try:
+    list(v)
+    if v[0] == "[" and v[-1] == "]":
+      return True
+    else:
+      return False
+  except Exception:
+    return False
+
+def is_digit(v: str):
+  try:
+    float(v)
+    return True
+  except Exception:
+    return False
+
+def is_bool(v: str):
+  if v in ["False", "True"]:
+    return True
+  else:
+    return False
+
+def dict_to_params(obj: dict):
+  params = ""
+  for k, v in obj.items():
+    if k == 'varname':
+      continue
+    v = str(v)
+    if not is_list(v) and not is_digit(v) and not is_bool(v):
+      if k == "path" and v[:4] != "http":
+        v = "r'%s'" % v
+      else:
+        v = "'%s'" % v
+    params += "%s=%s, " % (k, v)
+  params = params[:params.rfind(',')]
+  return params