新增网关列表查询接口、新增AES加密方法

Ansjer/server_urls/loocam_url.py

@@ -9,7 +9,7 @@
 from django.urls import re_path
 
 from Controller.SensorGateway import GatewayFamilyRoomController, SubDeviceController, GatewayFamilyMemberController, \
-    EquipmentFamilyController
+    EquipmentFamilyController,GatewayDeviceController
 
 urlpatterns = [
     re_path(r'^sensor/gateway/(?P<operation>.*)$', EquipmentFamilyController.EquipmentFamilyView.as_view()),
@@ -17,4 +17,5 @@ urlpatterns = [
     re_path(r'^gateway/family/member/(?P<operation>.*)$',
             GatewayFamilyMemberController.GatewayFamilyMemberView.as_view()),
     re_path(r'^gateway/subdevice/(?P<operation>.*)$', SubDeviceController.GatewaySubDeviceView.as_view()),
+    re_path(r'^gateway/device/info/(?P<operation>.*)$', GatewayDeviceController.GatewayDeviceView.as_view()),
 ]

Controller/SensorGateway/GatewayDeviceController.py

@@ -0,0 +1,101 @@
+# -*- encoding: utf-8 -*-
+"""
+@File    : GatewayDeviceController.py
+@Time    : 2022/6/6 13:50
+@Author  : stephen
+@Email   : zhangdongming@asj6.wecom.work
+@Software: PyCharm
+"""
+import time
+
+import oss2
+from django.db import connection
+from django.db import transaction
+from django.db.models import Q, Count
+from django.views.generic.base import View
+
+from Ansjer.config import OSS_STS_ACCESS_SECRET, OSS_STS_ACCESS_KEY
+from Controller.DeviceConfirmRegion import Device_Region
+from Model.models import Device_Info, UID_Bucket, UID_Preview, UidSetModel, UidChannelSetModel, \
+    iotdeviceInfoModel, UIDModel, Device_User, UserFamily, FamilyMember, FamilyMemberPermission, \
+    FamilyRoomDevice, FamilyRoom, GatewaySubDevice
+from Object.ResponseObject import ResponseObject
+from Object.TokenObject import TokenObject
+from Service.CommonService import CommonService
+
+
+class GatewayDeviceView(View):
+
+    def get(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+        operation = kwargs.get('operation')
+        return self.validation(request.GET, request, operation)
+
+    def post(self, request, *args, **kwargs):
+        request.encoding = 'utf-8'
+
+        operation = kwargs.get('operation')
+        return self.validation(request.POST, request, operation)
+
+    def validation(self, request_dict, request, operation):
+
+        token = TokenObject(request.META.get('HTTP_AUTHORIZATION'))
+        lang = request_dict.get('lang', None)
+        response = ResponseObject(lang) if lang else ResponseObject(token.lang)
+        if token.code != 0:
+            return response.json(token.code)
+        user_id = token.userID
+
+        # 手机端添加设备，查询，修改
+        if operation == 'list':
+            return self.gateway_device_list(request_dict, response)
+
+    @classmethod
+    def gateway_device_list(cls, request_dict, response):
+        device_id = request_dict.get('deviceId', None)
+        if not device_id:
+            return response.json(444)
+        device_qs = FamilyRoomDevice.objects.filter(device_id=device_id, sub_device=0)
+        if not device_qs.exists():
+            return response.json(173)
+        device_qs = device_qs.values('room_id', 'device__Type', 'device__NickName', 'device__UID',
+                                     'device__serial_number')
+        device_qs = device_qs.first()
+        room_id = device_qs['room_id']
+        gateway_room_name = ''
+        if room_id:
+            room_qs = FamilyRoom.objects.filter(id=room_id)
+            gateway_room_name = room_qs.first().name if room_qs.exists() else ''
+        gateway = {
+            'deviceType': device_qs['device__Type'],
+            'deviceNickName': device_qs['device__NickName'],
+            'UID': device_qs['device__UID'],
+            'serialNumber': device_qs['device__serial_number'],
+            'roomName': gateway_room_name
+        }
+        family_device_qs = FamilyRoomDevice.objects.filter(device_id=device_id)
+        family_device_qs = family_device_qs.filter(~Q(sub_device=0)).order_by('-created_time')
+
+        sub_device = []
+        if family_device_qs.exists():
+            for item in family_device_qs:
+                sub_id = item['sub_device']
+                gateway_sub_qs = GatewaySubDevice.objects.filter(device_id=device_id, id=sub_id).values(
+                    'id', 'device_type',
+                    'nickname',
+                    'src_addr', 'status',
+                    'created_time', )
+                rood_id = item['rood_id']
+                room_qs = FamilyRoom.objects.filter(id=rood_id)
+                gateway_room_name = room_qs.first().name if room_qs.exists() else ''
+                if device_qs.exists():
+                    gateway_sub_qs = gateway_sub_qs.first()
+                    sub_device.append({
+                        'id': gateway_sub_qs['id'],
+                        'nickName': gateway_sub_qs['nickname'],
+                        'srcAddr': gateway_sub_qs['src_addr'],
+                        'status': gateway_sub_qs['status'],
+                        'createdTime': gateway_sub_qs['created_time'],
+                        'roomName': gateway_room_name
+                    })
+        return response.json(0, {'gateway': gateway, 'sub_device': sub_device})

Object/utils/SymmetricCryptoUtil.py

@@ -0,0 +1,216 @@
+from Crypto.Cipher import AES
+import base64
+import binascii
+
+
+# 数据类
+class MData:
+    def __init__(self, data=b"", characterSet='utf-8'):
+        # data肯定为bytes
+        self.data = data
+        self.characterSet = characterSet
+
+    def saveData(self, FileName):
+        with open(FileName, 'wb') as f:
+            f.write(self.data)
+
+    def fromString(self, data):
+        self.data = data.encode(self.characterSet)
+        return self.data
+
+    def fromBase64(self, data):
+        self.data = base64.b64decode(data.encode(self.characterSet))
+        return self.data
+
+    def fromHexStr(self, data):
+        self.data = binascii.a2b_hex(data)
+        return self.data
+
+    def toString(self):
+        return self.data.decode(self.characterSet)
+
+    def toBase64(self):
+        return base64.b64encode(self.data).decode()
+
+    def toHexStr(self):
+        return binascii.b2a_hex(self.data).decode()
+
+    def toBytes(self):
+        return self.data
+
+    def __str__(self):
+        try:
+            return self.toString()
+        except Exception:
+            return self.toBase64()
+
+
+"""
+封装类
+"""
+
+
+class AESencrypt:
+    def __init__(self, encode_key, mode, iv_key=b'', paddingMode="NoPadding", characterSet="utf-8"):
+        """
+        构建一个AES对象
+        key: 秘钥，字节型数据
+        mode: 使用模式，只提供两种，AES.MODE_CBC, AES.MODE_ECB
+        iv： iv偏移量，字节型数据
+        paddingMode: 填充模式，默认为NoPadding, 可选NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding
+        characterSet: 字符集编码
+        """
+        self.key = encode_key
+        self.mode = mode
+        self.iv = iv_key
+        self.characterSet = characterSet
+        self.paddingMode = paddingMode
+        self.data = ""
+
+    @classmethod
+    def __zero_padding(cls, data):
+        data += b'\x00'
+        while len(data) % 16 != 0:
+            data += b'\x00'
+        return data
+
+    @classmethod
+    def __strip_zero_padding(cls, data):
+        data = data[:-1]
+        while len(data) % 16 != 0:
+            data = data.rstrip(b'\x00')
+            if data[-1] != b"\x00":
+                break
+        return data
+
+    def __PKCS5_7Padding(self, data):
+        needSize = 16 - len(data) % 16
+        if needSize == 0:
+            needSize = 16
+        return data + needSize.to_bytes(1, 'little') * needSize
+
+    def __StripPKCS5_7Padding(self, data):
+        paddingSize = data[-1]
+        return data.rstrip(paddingSize.to_bytes(1, 'little'))
+
+    def __paddingData(self, data):
+        if self.paddingMode == "NoPadding":
+            if len(data) % 16 == 0:
+                return data
+            else:
+                return self.__zero_padding(data)
+        elif self.paddingMode == "ZeroPadding":
+            return self.__zero_padding(data)
+        elif self.paddingMode == "PKCS5Padding" or self.paddingMode == "PKCS7Padding":
+            return self.__PKCS5_7Padding(data)
+        else:
+            print("不支持Padding")
+
+    def __stripPaddingData(self, data):
+        if self.paddingMode == "NoPadding":
+            return self.__strip_zero_padding(data)
+        elif self.paddingMode == "ZeroPadding":
+            return self.__strip_zero_padding(data)
+
+        elif self.paddingMode == "PKCS5Padding" or self.paddingMode == "PKCS7Padding":
+            return self.__StripPKCS5_7Padding(data)
+        else:
+            print("不支持Padding")
+
+    def setCharacterSet(self, characterSet):
+        """
+        设置字符集编码
+        characterSet: 字符集编码
+        """
+        self.characterSet = characterSet
+
+    def setPaddingMode(self, mode):
+        """
+        设置填充模式
+        mode: 可选NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding
+        """
+        self.paddingMode = mode
+
+    def decryptFromBase64(self, entext):
+        """
+        从base64编码字符串编码进行AES解密
+        entext: 数据类型str
+        """
+        mData = MData(characterSet=self.characterSet)
+        self.data = mData.fromBase64(entext)
+        return self.__decrypt()
+
+    def decryptFromHexStr(self, entext):
+        """
+        从hexstr编码字符串编码进行AES解密
+        entext: 数据类型str
+        """
+        mData = MData(characterSet=self.characterSet)
+        self.data = mData.fromHexStr(entext)
+        return self.__decrypt()
+
+    def decryptFromString(self, entext):
+        """
+        从字符串进行AES解密
+        entext: 数据类型str
+        """
+        mData = MData(characterSet=self.characterSet)
+        self.data = mData.fromString(entext)
+        return self.__decrypt()
+
+    def decryptFromBytes(self, entext):
+        """
+        从二进制进行AES解密
+        entext: 数据类型bytes
+        """
+        self.data = entext
+        return self.__decrypt()
+
+    def encryptFromString(self, data):
+        """
+        对字符串进行AES加密
+        data: 待加密字符串，数据类型为str
+        """
+        self.data = data.encode(self.characterSet)
+        return self.__encrypt()
+
+    def __encrypt(self):
+        """
+        加密数据
+        @return:
+        """
+        if self.mode == AES.MODE_CBC:
+            aes = AES.new(self.key, self.mode, self.iv)
+        elif self.mode == AES.MODE_ECB:
+            aes = AES.new(self.key, self.mode)
+        else:
+            print("不支持这种模式")
+            return
+
+        data = self.__paddingData(self.data)
+        enData = aes.encrypt(data)
+        return MData(enData)
+
+    def __decrypt(self):
+        if self.mode == AES.MODE_CBC:
+            aes = AES.new(self.key, self.mode, self.iv)
+        elif self.mode == AES.MODE_ECB:
+            aes = AES.new(self.key, self.mode)
+        else:
+            print("不支持这种模式")
+            return
+        data = aes.decrypt(self.data)
+        mData = MData(self.__stripPaddingData(data), characterSet=self.characterSet)
+        return mData
+
+
+if __name__ == '__main__':
+    key = b"1234567812345678"
+    iv = b"0000000000000000"
+    aes = AESencrypt(key, AES.MODE_CBC, iv, paddingMode="ZeroPadding", characterSet='utf-8')
+
+    str_data = "dddd321123."
+    rData = aes.encryptFromString(str_data)
+    print("加密：", rData.toBase64())
+    rData = aes.decryptFromBase64(rData.toBase64())
+    print("解密：", rData)