예제 #1
0
파일: senko.py 프로젝트: guljanjua/senko
    def _check_hash(self, x, y):
        x_hash = uhashlib.sha1(x.encode())
        y_hash = uhashlib.sha1(y.encode())

        x = x_hash.digest()
        y = y_hash.digest()

        if str(x) == str(y):
            return True
        else:
            return False
예제 #2
0
    def _check_hash(self, x, y):
        x_hash = uhashlib.sha1(x.encode())
        y_hash = uhashlib.sha1(y.encode())

        x = x_hash.digest()
        y = y_hash.digest()

        if str(x) == str(y):
            print("[Senko] No change")
            return True
        else:
            print("[Senko] Changes detected")
            return False
예제 #3
0
 def __init__(self, fhandle, mode):
     self.fd = fhandle
     self.hasher = hashlib.sha1()
     self.bread = 0
     self.bwrite = 0
     self.fileno = self.fd.fileno()
     self.__class__.FD[self.fileno] = self
예제 #4
0
파일: ws.py 프로젝트: pmp-p/fel-installer
def handshake(client):
    print("<handshake>")
    header = b""
    while header.find(b'\r\n\r\n') == -1:
        header += client.recv(16)
        if header.startswith(b'MTU='):
            return header.decode('utf8')

    lines = header.split(b"\r\n")
    d = dict()
    for line in lines[1:]:
        if not line: continue
        header, value = line.split(b": ", 1)
        d[header] = value

    # compute Response Key
    GUID = b'258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
    hash = sha1(d[b'Sec-WebSocket-Key'] + GUID)
    d = hash.digest()
    response_key = b64encode(d).strip().decode('ASCII')
    template = 'HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: %s\r\n\r\n'
    handshake = template % response_key
    client.send(handshake.encode())
    print("</handshake>")

    return 'ws'
예제 #5
0
    def server_handshake(self):
        clr = self.s.makefile("rwb", 0)
        l = clr.readline()
        #sys.stdout.write(repr(l))
        webkey = None
        while 1:
            l = clr.readline()
            if not l:
                raise OSError("EOF in headers")
            if l == b"\r\n":
                break
        #    sys.stdout.write(l)
            h, v = [x.strip() for x in l.split(b":", 1)]
            if DEBUG:
                print((h, v))
            if h == b'Sec-WebSocket-Key':
                webkey = v

        if not webkey:
            raise OSError("Not a websocket request")

        if DEBUG:
            print("Sec-WebSocket-Key:", webkey, len(webkey))

        respkey = webkey + b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
        respkey = hashlib.sha1(respkey).digest()
        respkey = binascii.b2a_base64(respkey)[:-1]

        resp = b'HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: %s\r\n\r\n' % respkey

        if DEBUG:
            print(resp)
        self.s.send(resp)
예제 #6
0
def make_respkey(webkey):
    d = uhashlib.sha1(webkey)
    d.update(b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
    respkey = d.digest()
    respkey = ubinascii.b2a_base64(respkey)  # [:-1]
    # Return with trailing "\n".
    return respkey
예제 #7
0
async def initiatewebsocket(w, secwebsocketkey):
    guid = b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
    acc = uhashlib.sha1(secwebsocketkey + guid).digest()
    acc = ubinascii.b2a_base64(acc).strip()
    await w.awrite(b"HTTP/1.1 101 Switching Protocols\r\n")
    await w.awrite(b"Upgrade: websocket\r\nConnection: Upgrade\r\n")
    await w.awrite(b"Sec-WebSocket-Accept: %s\r\n\r\n" % acc)
예제 #8
0
 def __generate_hmac(cls, key, message):
     """ HMAC-SHA1 implementation
         https://github.com/python/cpython/blob/3.8/Lib/hmac.py
     """
     key = key.encode()
     message = message.encode()
     if len(key) > cls.SHA1_BLOCK_SIZE:
         key = sha1(key).digest()
     key += (b'\x00' * (cls.SHA1_BLOCK_SIZE - len(key)))
     outer, inner = sha1(), sha1()
     inner.update(bytes((x ^ 0x36) for x in key))
     outer.update(bytes((x ^ 0x5C) for x in key))
     inner.update(message)
     outer.update(inner.digest())
     hmac = outer.digest()
     return binascii.b2a_base64(hmac).decode()[:-1]
예제 #9
0
def receive_ota(host, port, remote_hash):
    import uhashlib
    sockaddr = usocket.getaddrinfo(host, port)[0][-1]
    # You need this object even for numeric addresses

    sock = usocket.socket()
    sock.connect(sockaddr)
    f = open('tmp', 'wb')  # write the streamed data to a file
    # as we might not have enough memory for the entire thing
    # also calculate hash while streaming
    _hash = uhashlib.sha1()
    while True:
        d = sock.recv(1024)
        if len(d) == 0:
            break
        _hash.update(d)
        f.write(d)
    sock.close()
    f.close()
    local_hash = hexlify(_hash.digest()).decode('ascii')
    if local_hash != remote_hash:
        log("Got a bad file transfer? Hash mismatch")
        log("Local hash: %s, Remote hash: %s" % (local_hash, remote_hash))
        return False

    log("OTA Received correctly")
    return True
예제 #10
0
    def websocket_handshake(self, req, writer):
        try:
            import ubinascii as binascii
            import uhashlib as hashlib
            import uwebsocket as websocket
        except:
            import binascii
            import hashlib
            import websocket

        if b"Upgrade" in req.headers and b"Sec-WebSocket-Key" in req.headers:
            d = hashlib.sha1(req.headers[b"Sec-WebSocket-Key"])
            d.update(b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
            respkey = d.digest()
            respkey = binascii.b2a_base64(respkey)[:-1]
            yield from writer.awrite(b"""\
HTTP/1.1 101 Switching Protocols\r
Upgrade: websocket\r
Connection: Upgrade\r
Sec-WebSocket-Accept: """ + respkey + b"\r\n\r\n")
            ws = WSWrapper(req.reader.s, writer)
            yield from self.websocket_loop(ws)
        else:
            yield from picoweb.start_response(writer, status="400")
            yield from writer.awrite(
                "400 Missing Upgrade or Sec-WebSocket-Key for websocket connection.\r\n\r\n"
            )
            yield from writer.awrite("Your headers: %s\r\n" % req.headers)
            return True
예제 #11
0
def make_respkey(webkey):
    d = uhashlib.sha1(webkey)
    d.update(b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
    respkey = d.digest()
    respkey = ubinascii.b2a_base64(respkey) #[:-1]
    # Return with trailing "\n".
    return respkey
예제 #12
0
def run():
    productKey = "K3I5ZkgyZjkydGli"
    productSecret = "VUFyVE92YVJmSUNQ"
    rand = "q9f5UdAlh687grFl0JVuyY6095302ehd"
    imei = modem.getDevImei()
    VER = '1'

    h1 = uhashlib.md5()
    h1.update(imei + "," + productSecret + "," + rand)
    SIGN = ubinascii.hexlify(h1.digest()).decode()
    print("MD5:   %s" % SIGN)  # 8ab41bc1e5e74fbf9cec16a6e0990d89

    DATA = imei + ";" + rand + ";" + SIGN
    print("DATA:  %s  " %DATA)
    h1 = uhashlib.sha1(productSecret)
    res = ubinascii.hexlify(h1.digest()).decode()
    print(res)
    res = uhashlib.hash_sha1(res, 20)
    print("SHA1(PS) :  %s" % res)
    aes_key = res[0:16].upper()
    print("aes_key : %s" % aes_key)
    res = uhashlib.aes_ecb(aes_key, DATA)
    print(res)
    raw = uhashlib.hash_base64(res)
    print(raw)
    data = productKey + ";" + raw + ";" + VER
    url = "220.180.239.212:8415"
    # url = "192.168.25.64:30884"
    response = request.post(url, data=data)
    print(response.json())   # 获取到密钥
    # {'RESPCODE': 10200, 'RESPMSG': 'SUCCESS', 'SERVERURI': 'mqtt://220.180.239.212:8420', 'DS': 'd5f01bddfc994c037be90ede69399ac0'}
    return response.json()
def did_it_change(file_to_check: str, file_hash: bytes) -> int:
    try:
        with open(file_to_check, "rb") as fp:
            file_data = fp.read()
    except OSError:
        return 1
    else:
        return int(hashlib.sha1(file_data).digest() != file_hash)
예제 #14
0
def calc_websocket_resp(key):
    concatkey = key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
    binarr = uhashlib.sha1(concatkey).digest()
    #hexstr = ubinascii.hexlify(binarr)
    #print(hexstr)
    respkey = ubinascii.b2a_base64(binarr).decode('utf-8').rstrip()
    #respkey = respkey[:-1] # strips the \n
    return respkey
예제 #15
0
    def verify_patch(self, patch, received_checksum):
        h = uhashlib.sha1()
        h.update(patch)
        checksum = ubinascii.hexlify(h.digest()).decode()
        print("Computed checksum: {}".format(checksum))
        print("Received checksum: {}".format(received_checksum))

        if checksum != received_checksum:
            self.checksum_failure = True
            return False

        return True
예제 #16
0
파일: util.py 프로젝트: pramodag/ulnoiot
def _file_hashs(root):
    l = os.listdir(root)
    for f in l:
        gc.collect()
        st = os.stat("%s/%s" % (root, f))
        if st[0] & 0x4000:  # stat.S_IFDIR
            _file_hashs(root + "/" + f)
        else:
            file = root + "/" + f
            h = sha1()
            for l in open(file):
                h.update(l)
            print(ubinascii.hexlify(h.digest()).decode(), file[1:])
def convertsavepostfile(pname):
    lgen = flinesplitgen(pname, 80)
    linebreakhash = uhashlib.sha1(next(lgen)).digest()

    # get the headers
    for l in lgen:
        if l == b'\r\n':
            break
        k, v = bytes(l).split(b":")
        if k == b'Content-Disposition':
            for s in v.split(b";"):
                se = s.strip().split(b"=", 1)
                if len(se) == 2:
                    if se[0] == b"filename":
                        filename = se[1].strip(b'"').decode()

    log("convpostfile", filename)
    fout = open(filename, "wb")
    prelinebreak = b""  # used to handle the linebreak before the breakline
    for l in lgen:
        linehash = uhashlib.sha1(l).digest()
        if linehash == linebreakhash:
            if not prelinebreak:
                print("where the prelinebreak?")
            break
        if prelinebreak:
            fout.write(prelinebreak)
            prelinebreak = b""
        if len(l) == 2:
            prelinebreak = bytes(l)
            if prelinebreak != b"\r\n":
                prelinebreak = b""
        if not prelinebreak:
            fout.write(l)
            
    fout.close()
    os.remove(pname)
    
 def _handshake(self, httpResponse):
     try:
         key = self._httpCli.GetRequestHeaders().get(
             'Sec-WebSocket-Key', None)
         if key:
             key += self._handshakeSign
             r = sha1(key.encode()).digest()
             r = b2a_base64(r).decode().strip()
             httpResponse.WriteSwitchProto("websocket",
                                           {"Sec-WebSocket-Accept": r})
             return True
     except:
         pass
     return False
예제 #19
0
def tree(path):
    if (not exists(path)):
        raise OSError(2, )
    if (stat.S_ISDIR(uos.stat(path)[stat.ST_MODE])):
        l = {}
        li = listdir(path)
        for i in li:
            l[i] = tree(path + '/' + i)
        return l
    else:
        with open(path, "rb") as file:
            sha1v = sha1()
            sha1v.update(file.read())
            return hexlify(sha1v.digest())
def ducos1(lastBlockHash, expectedHash,
           difficulty):  # Loop from 1 too 100*diff
    hashcount = 0
    for ducos1res in range(100 * int(difficulty) + 1):
        ducos1 = hashlib.sha1(
            str(lastBlockHash + str(ducos1res)).encode("utf-8"))
        ducos1 = ubinascii.hexlify(ducos1.digest()).decode()  # Generate hash
        time.sleep(0.005)
        hashcount += 1  # Increment hash counter for hashrate calculator
        # Next line was used for debugging, uncomment it to see the miner work :3
        # print(str(ducos1) + " | " + str(expectedHash))
        if ducos1 == expectedHash:
            print("Hash found, sending for feedback...")
            return [ducos1res, hashcount]
예제 #21
0
파일: myhash.py 프로젝트: G4bzh/FabLab
def mysha1(path):
	try:
		sh = uhashlib.sha1()
		f=open(path)
		while True:
		    data = f.read(1)
		    if not data:
		        break
		    sh.update(data)
		f.close()
		return ubinascii.hexlify(sh.digest()).upper()
	except:
		print("SHA1 Error")
		return 0
예제 #22
0
def ClientHandshake(conn, data):
    data = data.decode().split('\r')
    for items in data:
        if 'Sec-WebSocket-Key' in items:
            print('Socket handshaking...')
            key = items.split(': ')[1]
            resp = key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
            resp = hashlib.sha1(resp).digest()
            resp = binascii.b2a_base64(resp)[:-1]
            response = "HTTP/1.1 101 Switching Protocols\r\n" + \
                "Upgrade: websocket\r\n" + \
                "Connection: Upgrade\r\n" + \
                "Sec-WebSocket-Accept: %s\r\n\r\n" % (
                    resp.decode("utf-8"))
            conn.send(response.encode())
            print('Client is connected!!!')
예제 #23
0
def server_handshake(sock):
    clr = sock.makefile("rwb", 0)
    l = clr.readline()
    if DEBUG:
        print("l: %s" % repr(l))

    webkey = None

    while 1:
        l = clr.readline()
        if not l:
            raise OSError("EOF in headers")
        if l == b"\r\n":
            break
        if DEBUG:
            print("l: %s" % l)
    #    sys.stdout.write(l)
        h, v = [x.strip() for x in l.split(b":", 1)]
        if DEBUG:
            print("h: %s" % h)
            print("v: %s" % v)
        if h == b'Sec-WebSocket-Key':
            webkey = v

    if not webkey:
        raise OSError("Not a websocket request")

    if DEBUG:
        print("Sec-WebSocket-Key:", webkey, len(webkey))

    d = hashlib.sha1(webkey)
    d.update(b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
    respkey = d.digest()
    respkey = binascii.b2a_base64(respkey)[:-1]
    if DEBUG:
        print("respkey:", respkey)

    sock.send(b"""\
HTTP/1.1 101 Switching Protocols\r
Upgrade: websocket\r
Connection: Upgrade\r
Sec-WebSocket-Accept: """)
    sock.send(respkey)
    sock.send("\r\n\r\n")
def server_handshake(sock):
    print("start_handshake")
    clr = sock.makefile("rwb", 0)
    l = clr.readline()
    #sys.stdout.write(repr(l))

    webkey = None

    while 1:
        l = clr.readline()
        if not l:
            raise OSError("EOF in headers")
        if l == b"\r\n":
            break
    #    sys.stdout.write(l)
        h, v = [x.strip() for x in l.split(b":", 1)]
        if DEBUG:
            print("h, v:")
            print((h, v))
        if h == b'Sec-WebSocket-Key':
            webkey = v

    if not webkey:
        raise OSError("Not a websocket request")

    if DEBUG:
        print("Sec-WebSocket-Key:", webkey, len(webkey))

    respkey = webkey + b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
    respkey = hashlib.sha1(respkey).digest()
    respkey = binascii.b2a_base64(respkey)[:-1]

    resp = b"""\
HTTP/1.1 101 Switching Protocols\r
Upgrade: websocket\r
Connection: Upgrade\r
Sec-WebSocket-Accept: %s\r
\r
""" % respkey

    if DEBUG:
        print(resp)
    sock.send(resp)
예제 #25
0
    def __load_file(self, conf_file):
        """Loading configuration file

        Loads configuration file, server adress,
        wifi SSID and password

        Args:
            conf_file (str): configuration file
        """
        with open(conf_file) as inp:
            self.conf = json.load(inp)

        self.conf['SERVER'] = tuple(self.conf['SERVER'])
        mac = hexlify(network.WLAN().config('mac'), ':')
        pass_hash = sha1(self.conf['OVR'].encode('utf-8'))
        pass_hash = hexlify(pass_hash.digest())

        self.data['MAC'] = mac.decode('utf-8')
        self.data['OVR'] = pass_hash.decode('utf-8')
        self.data['NAME'] = self.conf['NAME']
예제 #26
0
def dl(url, debug=False):
    import uhashlib
    import ubinascii

    proto, dummy, host, path = url.split("/", 3)
    ai = socket.getaddrinfo(host, 80)
    addr = ai[0][4]
    s = socket.socket()
    s.settimeout(10)
    try:
        s.connect(addr)
        s.write(b"GET /%s HTTP/1.0\r\nHost: %s\r\n\r\n" % (path, host))
        size = 0
        hash = uhashlib.sha1()
        t = time.ticks_ms()
        buf = s.read(2000)
        assert buf, buf
        if debug:
            print("initial response:", buf)
        header, buf = buf.split(b"\r\n\r\n", 1)
        #print(header)
        #print(buf)
        hash.update(buf)
        size += len(buf)
        while 1:
            buf = s.read(1024)
            if buf == b"": break
            hash.update(buf)
            size += len(buf)
            sys.stdout.write("%dK\r" % (size >> 10))
#            sta.active(False)
        delta = time.ticks_diff(time.ticks_ms(), t)
        #print()
        print("Size :", size)
        print("Speed: %s bytes/s" % (size / delta * 1000))
        print("Elapsed: %s" % (delta / 1000))
        sha = str(ubinascii.hexlify(hash.digest()), "ascii")
        print("SHA1 :", sha)
        return size, sha
    finally:
        s.close()
예제 #27
0
def websocket_ctl(data_ws):  #WebSocket控制
    if data_ws.find(b'Connection: Upgrade') != -1:
        client_key_beg = data_ws.find(b'Sec-WebSocket-Key:') + 19
        client_key_end = data_ws.find(b'\r\n', client_key_beg)
        client_key = data_ws[client_key_beg:client_key_end]
        #print('client_key:', client_key)     #Debug mode
        server_key = (ubinascii.b2a_base64(
            uhashlib.sha1(client_key +
                          magic_key).digest()).decode('utf-8')).strip()
        #print('server_key:', server_key)     #Debug mode
        cl.sendall("%s" % (header_101 % (server_key)))
        print('[Info]: Open WebSocket!!!')
        while True:
            data = cl.recv(1024)
            #print(data)     #Debug mode
            msg = parse_recv_data(data)
            #print(msg)     #Debug mode
            if msg.find("control&go-value=") != -1:  #前进
                #go_value_beg = msg.find("control&go-value=") + 17
                #go_value_end = go_value_beg + 2
                go_value = int(msg[17:]) + 51
                pwm12.duty(go_value)
                print("go_value:", go_value)  #Debug mode
            if msg.find("control&turn-value=") != -1:  #左右
                #turn_value_beg = msg.find("control&turn-value=") + 19
                #turn_value_end = turn_value_beg + 2
                if int(msg[19:]) >= 26:  #右转
                    turn_value = int(msg[19:]) - 26
                    pwm5.duty(77 - turn_value)
                    print("turn_value:", (77 - turn_value))  #Debug mode
                if int(msg[19:]) < 26:  #左转
                    turn_value = int(~int(msg[19:]) + 26)
                    pwm5.duty(77 + turn_value)
                    print("turn_value:", (77 + turn_value))  #Debug mode
            if msg == "Close connection":  #正常关闭连接
                print('[Info]: Close WebSocket!!!')
                break
            elif msg == " ":  #非正常关闭连接
                print('[Warning]: Abnormal closure WebSocket!!!')
                break
예제 #28
0
 def __init__(self, repopath, prefixes=[], suite='ndn2013'):
     self._path = repopath
     self._prefixes = []
     for fn in os.listdir(self._path):
         t = fn.split('.')
         if t[0] != 'prefix':
             continue
         with open(self._path + '/' + fn, 'rb') as f:
             buf = f.read()
         pkt = pycn_lite.lib.suite.multi.decode_wirebytes(buf)
         if not isinstance(pkt, pycn_lite.lib.packet.InterestPacket):
             continue
         self._prefixes.append(pkt._name)
     for pfx in prefixes:
         if not pfx in self._prefixes:
             wb = pfx._suite.enc.encode_interest_wirebytes(pfx._comps)
             h = sha1()
             h.update(wb)
             fn = self._path + '/prefix.' + h.hexdigest()[:24]
             with open(fn, 'wb') as f:
                 f.write(wb)
             self._prefixes.append(pfx)
def mining(i, username):
    addr = usocket.getaddrinfo('51.15.127.80', 2811)[0][-1]
    soc = usocket.socket()
    soc.connect(addr)
    soc.recv(3).decode()
    while True:
        try:
            soc.send(bytes("JOB," + str(username) + ",ESP",
                           "utf8"))  # Send job request
            job = soc.recv(1024).decode()  # Get work from pool
            job = job.split(
                ",")  # Split received data to job (job and difficulty)
            difficulty = job[2]
            start = time.time()
            for result in range(100 * int(difficulty) +
                                1):  # Calculate hash with difficulty
                ducos1 = str(
                    ubinascii.hexlify(
                        uhashlib.sha1(str(job[0] + str(result))).digest()))
                if job[1] == ducos1[2:42]:
                    end = time.time()
                    hastime = end - start
                    hashrate = result / hastime
                    soc.send(
                        bytes(
                            str(result) + "," +
                            ",Multithread ESP32 MicroPython", "utf8"))
                    feedback = soc.recv(1024).decode()
                    if feedback == "GOOD":  # If result was good
                        print("Thread:", i, "Accepted share", result,
                              "Difficulty", difficulty, "Hashrate", hashrate,
                              "H/s", "Hashtime", hastime)
                        break
                    elif feedback == "BAD":  # If result was bad
                        print("Thread:", i, "Rejected share", result,
                              "Difficulty", difficulty)
                        break
        except Exception as err:
            print(err)
예제 #30
0
    def get_data(self, req, dest_path=None, hash=False, firmware=False):
        # Connect to server
        print("Requesting: {}".format(req))
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM,
                          socket.IPPROTO_TCP)
        s.connect((self.ip, self.port))

        # Request File
        s.sendall(self._http_get(req, "{}:{}".format(self.ip, self.port)))

        try:
            content = bytearray()
            fp = None
            if dest_path is not None:
                if firmware:
                    raise Exception("Cannot write firmware to a file")
                fp = open(dest_path, 'wb')

            if firmware:
                pycom.ota_start()

            h = uhashlib.sha1()

            # Get data from server
            result = s.recv(100)

            start_writing = False
            while (len(result) > 0):
                # Ignore the HTTP headers
                if not start_writing:
                    if "\r\n\r\n" in result:
                        start_writing = True
                        result = result.decode().split("\r\n\r\n")[1].encode()

                if start_writing:
                    if firmware:
                        pycom.ota_write(result)
                    elif fp is None:
                        content.extend(result)
                    else:
                        fp.write(result)

                    if hash:
                        h.update(result)

                result = s.recv(100)

            s.close()

            if fp is not None:
                fp.close()
            if firmware:
                pycom.ota_finish()

        except Exception as e:
            # Since only one hash operation is allowed at Once
            # ensure we close it if there is an error
            if h is not None:
                h.digest()
            raise e

        hash_val = ubinascii.hexlify(h.digest()).decode()

        if dest_path is None:
            if hash:
                return (bytes(content), hash_val)
            else:
                return bytes(content)
        elif hash:
            return hash_val
예제 #31
0
def sha1Hash(val):
    return str(hexlify(sha1(val).digest()), 'utf-8')
예제 #32
0
import sys
try:
    import uhashlib as hashlib
except ImportError:
    try:
        import hashlib
    except ImportError:
        # This is neither uPy, nor cPy, so must be uPy with
        # uhashlib module disabled.
        print("SKIP")
        sys.exit()

try:
    hashlib.sha1
except AttributeError:
    # SHA1 is only available on some ports
    print("SKIP")
    sys.exit()

sha1 = hashlib.sha1(b'hello')
sha1.update(b'world')
print(sha1.digest())
예제 #33
0
import socket
addr = socket.getaddrinfo('0.0.0.0', 7000)[0][-1]

s = socket.socket()
s.bind(addr)
s.listen(10)
print('listening on', addr)

while True:
    import test
    cl, addr = s.accept()
    req = cl.recv(1024)
    reqToObj = test.requestParse(req)
    magicString = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
    test = uhashlib.sha1(reqToObj['Sec-WebSocket-Key']+magicString)
    # print('test xxxxxx', uhashlib.sha1("dGhlIHNhbXBsZSBub25jZQ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest())
    accept = test.digest()
    # print('SHA1AAAAAAAAAAAAAAAAAAAAAAAA',accept)
    # print('SHA1AAAAAAAAAAAAAAAAAAAAAAAA',accept)
    a1 = ubinascii.b2a_base64(accept)
    b1 = a1.decode()
    # print('xxxxxxxxxxxxxxx', a1.decode())
    # print(reqToObj)
    print('client connected from', addr)
    cl.send('HTTP/1.1 101 Switching Protocols\n')
    cl.send('Upgrade: websocket\n')
    cl.send('Connection: Upgrade\n')
    cl.send('Sec-WebSocket-Accept: '+ b1 + '\n\n')
    # www = cl.read()
    while True:
예제 #34
0
def socket_handler(listen_s):
    gc.collect()

    try:
        client, remote_addr = listen_s.accept()
        if not client.readline() == b'GET / HTTP/1.1\r\n':
            client.close()
            return

        ws = None
        ws_key = None

        while True:
            line = client.readline()
            if line == b'\r\n' or line == b'':
                break
            h, v = [x.strip() for x in line.split(b':', 1)]
            if h == b'Connection':
                if v == b'Upgrade':
                    ws = True
            elif h == b'Sec-WebSocket-Key':
                ws_key = v
            print(v, h)
        if not ws:
            client.close()
            return
        print('Got valid socket connection from', remote_addr)
        d = uhashlib.sha1(ws_key)
        d.update(b'258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
        client.send(b'\\n'
                    b'HTTP/1.1 101 Switching Protocols\r\n'
                    b'Upgrade: websocket\r\n'
                    b'Connection: Upgrade\r\n'
                    b'Sec-WebSocket-Accept: ')
        client.send(ubinascii.b2a_base64(d.digest())[:-1])
        client.send(b'\r\n\r\n')
        ws = websocket.websocket(client)

        def socket_handler_inner(client):
            global settings
            cmd = ws.readline().strip()
            if len(cmd) == 0:
                ws.close()
                client.close()
                return
            elif cmd == b'get':
                ws.write(json.dumps(settings))
                ws.write(b'OK\n')
            elif cmd == b'set':
                settings = json.loads(ws.readline())
                ws.write(b'OK\n')
            elif cmd == b'exec':
                try:
                    exec(ws.readline())
                    ws.write(b'OK\n')
                except Exception as e:
                    print('error', e)
                    ws.write(b'ERROR\n')
                    ws.write(json.dumps(repr(e)))
                    ws.write(b'\n')
            else:
                ws.write(b'ERROR\nUnknown action')
                ws.write(cmd)
                ws.write(b'\n')

        client.setblocking(False)
        client.setsockopt(socket.SOL_SOCKET, 20, socket_handler_inner)
        gc.collect()
    except Exception as e:
        print('Error handing socket:', e)
예제 #35
0
 def encrypt(string):
     string_hash = uhashlib.sha1(string)
     string_hash.update(config['SECRET_SALT'])
     string_hash = string_hash.digest()
     string_hash = ubinascii.hexlify(string_hash)
     return string_hash