Das deutsche Python-Forum

Code: Alles auswählen

   def listing(self):
        
        BIT_AKTIV = 1 << 7
        BIT_WRITABLE = 1 << 6
        BIT_PASSWORT = 1 << 4
        BIT_PASSAktiv = 1 << 3
        BIT_SPEICHER = 1 << 0


        data = bytearray.fromhex("FF 4E")
        data.append(ChecksumXor8.calc(data))
        
        try:
            serial_interface.reset_input_buffer()
            serial_interface.reset_output_buffer()#flush output buffer, aborting current output 
            time.sleep(0.01)  #give the serial port sometime to receive the data
            serial_interface.write(data)
            time.sleep(0.01)
            response = serial_interface.read(7)
            number_of_datafields=int.from_bytes(response[3:4],'big',signed=False)

        except Exception as e1:
            print ("error communicating...: " + str(e1))

        self.datenfeld_info.config(state='normal')
        self.datenfeld_info.delete('2.0','end')


        i=0
        for i in range(number_of_datafields):
            data = bytearray([0xff, 0x4c, i])
            data.append(ChecksumXor8.calc(data))
            try:
                serial_interface.reset_input_buffer()
                serial_interface.reset_output_buffer()
                time.sleep(0.010) 
                serial_interface.write(data)
                time.sleep(0.01)
                response = serial_interface.read(7)
            
                if response[0] == 0x50 or ChecksumXor8.calc(response) != 0:
                    print(sick_error.srm_errors(hex(response[1])))
                else:
                    datenfeld = response[3]
                    nummer = '\n' + str(i) + '\t'
                    enabled = "ja\t" if datenfeld & BIT_AKTIV else "nein\t"

                    writeable = "ja\t" if datenfeld & BIT_WRITABLE else "nein\t"

                    password = str(datenfeld & BIT_PASSWORT)+'\t'
        
                    password_active = "ja\t" if datenfeld & BIT_PASSAktiv else "nein\t"
        
                    speichergroese = str((1 + (datenfeld & BIT_SPEICHER)) * 16) + '\t'
                    
                    data = nummer + enabled + writeable +  password + password_active + speichergroese
                    self.datenfeld_info.insert('end',data)
                    
                    
            
            except Exception as e1:
                print ("error communicating...: " + str(e1))

Code: Alles auswählen

BIT_AKTIV = 1 << 7
BIT_WRITABLE = 1 << 6
BIT_PASSWORT = 1 << 4
BIT_PASSWORD_ACTIVE = 1 << 3
MEMORY_SIZE_MASK = 0b0000_0111


def communicate(serial_interface, request):
    request_data = bytearray(request)
    request_data.append(ChecksumXor8.calc(request_data))
    serial_interface.reset_input_buffer()
    serial_interface.reset_output_buffer()
    time.sleep(0.01)
    serial_interface.write(request_data)
    time.sleep(0.01)
    response = serial_interface.read(7)
    if ChecksumXor8.calc(response) != 0:
        raise ChecksumXor8.ChecksumError()

    if response[0] == 0x50:
        raise sick_error.SRMError(response[1])

    return response

...

    def listing(self, serial_interface):
        datafield_count = int.from_bytes(
            communicate(serial_interface, [0xFF, 0x4E])[3:4], "big"
        )
        self.datenfeld_info.config(state=tk.NORMAL)
        self.datenfeld_info.delete("2.0", tk.END)
        for index in range(datafield_count):
            try:
                value = communicate(serial_interface, [0xFF, 0x4C, index])[3]
            except:
                logging.exception("error communicating...")
            else:
                row = [
                    str(index),
                    "ja" if value & BIT_AKTIV else "nein",
                    "ja" if value & BIT_WRITABLE else "nein",
                    str(value & BIT_PASSWORT),
                    ("ja" if value & BIT_PASSWORD_ACTIVE else "nein"),
                    str((1 + (value & MEMORY_SIZE_MASK)) * 16),
                ]
                self.datenfeld_info.insert(tk.END, "\t".join(row) + "\n")

Code: Alles auswählen

def bit_knacker(num):
    res = int(num, 16)
    byt = format(res, '08b') # '11001001'
    data = {'nummer': num, 'enabled': '', 'writable': '',  'password': '', 'password_aktiv': '', 'memory': '' }
    data['password'] = byt[2:4] +"\t" # watn dat fürn passwort?
    data['memory'] = byt[5:] +"\t"
    if int(byt[0:1]) == '0':
        data['enabled'] = "nein\t" 
    else: 
        data['enabled'] = "ja\t"
    if byt[1:2] == '0':
        data['writable' ]= "nein\t" 
    else: 
        data['writable' ] = "ja\t"
    if byt[4:5] == '0':
        data['password_aktiv'] = "nein\t" 
    else: 
        data['password_aktiv'] = "ja\t"
    return data

bites = ['11001001', '10101010', '01010101', '11011011', '00111101']
for b in bites:
    num = int(b, 2)
    num = hex(num)
    print('************')
    res = bit_knacker(num)
    for key in res.keys():
        print(key, res[key])

Code: Alles auswählen

from attrs import define, field, make_class
from attrs.validators import min_len, and_, max_len

result = make_class(
    name="Result",
    attrs=["enabled", "writable", "password", "password_active", "memory"],
)


@define(frozen=True)
class Encrypter:
    ENABLED = 0
    WRITABLE = 1
    PASSWORD = 2
    PASSWORD_STATE = 4
    MEMORY = 5

    bytes = field(validator=and_(min_len(8), max_len(8)))

    def __call__(self):
        return result(
            self.bytes[self.ENABLED] == "1",
            self.bytes[self.WRITABLE] == "1",
            self.bytes[self.PASSWORD : self.PASSWORD_STATE],
            self.bytes[self.PASSWORD_STATE] == "1",
            self.bytes[self.MEMORY :],
        )


def main():
    for data in [b"11001001", b"10101010", b"01010101", b"11011011", b"00111101"]:
        encrypted = Encrypter(data)()
        print(encrypted)
        print(f"Just the password: {encrypted.password}\n")



if __name__ == "__main__":
    main()

Code: Alles auswählen

#!/usr/bin/env python3


def parse(value):
    return {
        "value": hex(value),
        "enabled": "yes" if value & 0b1000_0000 else "no",
        "writable": "yes" if value & 0b0100_0000 else "no",
        "password": f"{(value & 0b0011_0000) >> 4:02b}",
        "password_active": "yes" if value & 0b0000_1000 else "no",
        "memory_size": f"{value & 0b0000_0111:03b}",
    }


def main():
    byte_values = [0b11001001, 0b10101010, 0b01010101, 0b11011011, 0b00111101]
    for byte_value in byte_values:
        print("*" * 16)
        for key, value in parse(byte_value).items():
            print(key, value)


if __name__ == "__main__":
    main()

Code: Alles auswählen

def bit_knacker(num):
    return {
        'nummer': num,
        'enabled': 'ja' if num & 128 else 'nein',
        'writable': 'ja' if num & 64 else 'nein',
        'password': (num >> 3) & 3,
        'password_aktiv': 'ja' if num & 32 else 'nein',, 
        'memory': num & 7,
    }
 
bits = ['11001001', '10101010', '01010101', '11011011', '00111101']
for bit in bits:
    num = int(b, 2)
    print('************')
    res = bit_knacker(num)
    for key, value in res.items():
        print(key, value)

Code: Alles auswählen

from attrs import define, field, make_class
from attrs.validators import le as less_than

result = make_class(
    name="Result",
    attrs=["enabled", "writable", "password", "password_active", "memory"],
)


@define(frozen=True)
class Decoder:
    ENABLED = 128
    WRITABLE = 64
    PASSWORD = 3
    PASSWORD_STATE = 32
    MEMORY = 7

    byte = field(validator=less_than(256), converter=lambda x: int(x, 2))

    def decode(self):
        return result(
            self.byte & self.ENABLED > 0,
            self.byte & self.WRITABLE > 0,
            (self.byte >> self.PASSWORD) & self.PASSWORD,
            self.byte & self.PASSWORD_STATE > 0,
            self.byte & self.MEMORY,
        )


def main():
    for data in [b"11001001", b"10101010", b"01010101", b"11011011", b"00111101"]:
        encrypted = Decoder(data).decode()
        print(encrypted)
        print(f"Just the password: {encrypted.password}\n")


if __name__ == "__main__":
    main()

Code: Alles auswählen

import json

savepath = '/home/peterr/temp/json/bit_knacker.json'   
 
bites = ['11001001', '10101010', '01010101', '11011011', '00111101']
data2json = []
for b in bites:
    num = int(b, 2)
    num = hex(num)
    print('************')
    res = bit_knacker(num)
    data2json.append(res)

with open(savepath, "w") as file:
   json.dump(data2json, file, indent=4)

Code: Alles auswählen

def bit_knacker_sirius(num):
    data_dict =  {
                            'nummer': format(num, '08b'),
                            'enabled': 'ja' if num & 128 else 'nein',
                            'writable': 'ja' if num & 64 else 'nein',
                            'password': format((num >> 4 & 3), '02b'), # (num >> 3 & 3) ergibt falsches Ergebnis mit '11001000' bits 2&3 von links sind null
                            'password_aktiv': 'ja' if num & 8 else 'nein', # sollte 8 sein, nicht 32
                            'memory': format((num & 7), '03b')}
    return data_dict

def bit_knacker_pedro(num):
    byt = format(num, '08b') # '11001001'
    print(f'binarynummer: {byt}')
    data = {'nummer': format(num, '08b'),
                'enabled': 'ja' if byt[0] == '1' else 'nein',
                'writable': 'ja' if byt[1] == '1' else 'nein',
                'password': byt[2:4],
                'password_aktiv': "nein"  if byt[4] == '0' else 'ja',
                'memory': byt[5:]}
    return data

for i in range(200, 256):
    res_siri = bit_knacker_sirius(i)
    res_pedro = bit_knacker_pedro(i)
    print(f'Beide dicts gleich? {res_siri == res_pedro}')
    print(f'siri: {res_siri}')
    print(f'pedro: {res_pedro}')

Code: Alles auswählen

#!/usr/bin/env python3
from attrs import asdict, define, field
from bitstring import Bits, pack

DATA_FIELD_FORMAT = "bool, bool, uint:2, bool, uint:3"


@define
class DataField:
    enabled = field()
    writable = field()
    password = field()
    password_active = field()
    memory_size = field()

    def __int__(self):
        return pack(
            DATA_FIELD_FORMAT,
            self.enabled,
            self.writable,
            self.password,
            self.password_active,
            self.memory_size // 16 - 1,
        ).uint

    @classmethod
    def from_int(cls, value):
        enabled, writable, password, password_active, memory_size = Bits(
            uint=value, length=8
        ).unpack(DATA_FIELD_FORMAT)
        return cls(
            enabled,
            writable,
            password,
            password_active,
            (memory_size + 1) * 16,
        )


def main():
    byte_values = [0b11001001, 0b10101010, 0b01010101, 0b11011011, 0b00111101]
    for byte_value in byte_values:
        print("*" * 16)
        data_field = DataField.from_int(byte_value)
        assert byte_value == int(data_field)
        print(asdict(data_field))


if __name__ == "__main__":
    main()