예제 #1
0
def test048_savePajek1_saveDot1():
    # This test requires to save/load/remove two files fron disk.
    g = Graph()
    g.addNode(1, nodeData=(256,128) )
    g.addNode(2+3J, nodeData=(6,11) )
    g.addNode((1,2), nodeData=(0,0) )
    g.addNode("a", nodeData=(1,1) )
    g.addBiArc(1, 2+3J, w=-2.1)
    g.addArc((1,2), 1, w=5)
    g.addArc(1, (1,2), w=1)
    g.addArc((1,2), 2+3J, w=11)
    g.addBiArc((1,2), "a", w=22)
    g.addBiArc(1,1, w=0)
    filename = "temp.paj"
    g.savePajek(filename)
    from bz2 import decompress
    from base64 import standard_b64decode
    from os import remove
    d = r"QlpoOTFBWSZTWUt6mzsAAB7fgAAQUH9/QCIAEQAusBwAIABqGqeFMmIMgGhiDTKTagABoAIdlpWRKsYoEkrTN7L0Q11CpFrFVxGkwEducZmeAE4o8xZPFFpGEyBYp84M8UWIhJB5kJFEOXB8hACdS4VoB78BSvVIAWrZ7CEPxdyRThQkEt6mzsA="
    assert open(filename).read() == decompress(standard_b64decode(d))
    remove(filename)

    filename = "temp.dot"
    g.saveDot(filename)
    d = r"QlpoOTFBWSZTWWJy76UAAEZfgAAQUG54AwCAAAo+9d8KIACKCVMkxDRHijQPUBsoJRENAAAA0BHOTIro1EW2CuVXKqcWM1Ts1zn4dA60ZJ6bNkZeEfMQsBUUIbWjRWKwu2B4P6zAcJJWoODdYyQY1CAXtCAewvvvSZ3xroFAjKFgzoGQQeyjwsVCN0XZNX3n/F3JFOFCQYnLvpQ="
    assert open(filename).read() == decompress(standard_b64decode(d))
    remove(filename)
예제 #2
0
파일: meta.py 프로젝트: martindurant/zarr
def decode_fill_value(v, dtype):
    # early out
    if v is None:
        return v
    if dtype.kind == 'f':
        if v == 'NaN':
            return np.nan
        elif v == 'Infinity':
            return np.PINF
        elif v == '-Infinity':
            return np.NINF
        else:
            return np.array(v, dtype=dtype)[()]
    elif dtype.kind == 'S':
        # noinspection PyBroadException
        try:
            v = base64.standard_b64decode(v)
        except Exception:
            # be lenient, allow for other values that may have been used before base64
            # encoding and may work as fill values, e.g., the number 0
            pass
        v = np.array(v, dtype=dtype)[()]
        return v
    elif dtype.kind == 'V':
        v = base64.standard_b64decode(v)
        v = np.array(v, dtype=dtype.str).view(dtype)[()]
        return v
    elif dtype.kind == 'U':
        # leave as-is
        return v
    else:
        return np.array(v, dtype=dtype)[()]
예제 #3
0
    def __decrypt_py2(secret, encrypted_value, logger):
        # If the string length is 0 or no secret was passed in, return the empty string.
        if not encrypted_value or not secret:
            return encrypted_value

        parts = encrypted_value.split("!")
        if len(parts) != 2:
            logger.warn('Encrypted value "%s" not in standard encrypted format, decryption skipped.' % encrypted_value)
            return encrypted_value

        iv_text = parts[0]
        encrypted_text = parts[1]
        iv_bytes = base64.standard_b64decode(iv_text)
        secret_bytes = base64.standard_b64decode(secret)

        if len(iv_bytes) != 16:
            logger.warn('Initialization Vector for "%s" not valid, decryption skipped.' % encrypted_value)
            return encrypted_value
        if len(secret_bytes) != 32:
            logger.warn('Passed in secret length is invalid, decryption skipped.')
            return encrypted_value

        cipher = Cipher(algorithms.AES(secret_bytes), modes.CBC(iv_bytes), backend=default_backend())
        decryptor = cipher.decryptor()
        decrypted_bytes = decryptor.update(base64.standard_b64decode(encrypted_text)) + decryptor.finalize()

        decrypted_string = decrypted_bytes.encode('utf-8')
        return ''.join([char for char in decrypted_string if ord(char) > 31])
예제 #4
0
파일: keestand.py 프로젝트: 912d/code
 def post(self):
   username = self.request.get("username")
   assert username
   password_hash = self.request.get("password_hash")
   assert password_hash
   query = User.all()
   query.filter("username ="******"".join([chunk.chunk for chunk in chunks])
     if passwords:  # Existing data.
       self.response.out.write(json.dumps(
         { "version" : user.version,
           "last_modified": time.mktime(user.last_modified.timetuple()),
           "passwords": Decode(passwords) }))
   else:  # New user.
     salt = self.request.get("salt")
     assert salt
     user = User(
         version = 2, username = username,
         salt = db.Blob(base64.standard_b64decode(salt)),
         password_hash = db.ByteString(
             base64.standard_b64decode(password_hash)))
     user.put()
   SetUserCookie(self.response, username, password_hash)
예제 #5
0
    def __doCerts(self, sts, sks, token):
        
        home = expanduser("~")
        
#         if os.path.exists(home + '/magistral') == False:
#             os.makedirs(home + '/magistral')
             
        if os.path.exists(home + '/magistral/tmp') == False:
            os.makedirs(home + '/magistral/tmp')
        
        with open(home + '/magistral/tmp/ts', 'wb') as f:
            f.seek(0)
            f.write(bytearray(base64.standard_b64decode(sts)))
            f.close()
    
        with open(home + '/magistral/tmp/ks', 'wb') as f:
            f.seek(0)
            f.write(bytearray(base64.standard_b64decode(sks)))                    
            f.close()           
                           
        ks = jks.KeyStore.load(home + '/magistral/tmp/ks', 'magistral')
            
        self.uid = JksHandler.writePkAndCerts(ks, token)
        
        if os.path.exists(home + '/magistral/tmp'): 
            shutil.rmtree(home + '/magistral/tmp')
예제 #6
0
 def do_authn(self):
     try:
         header = cherrypy.request.headers['Authorization']
     except KeyError:
         self.critical_error("No authentication data presented")
     auth_type, auth_content = header.split()
     try:
         # py3k compatibility
         auth_content = base64.standard_b64decode(auth_content)
     except TypeError:
         auth_content = \
             base64.standard_b64decode(bytes(auth_content.encode('ascii')))
     try:
         # py3k compatibility
         try:
             username, password = auth_content.split(":")
         except TypeError:
             username, pw = auth_content.split(bytes(":", encoding='utf-8'))
             password = pw.decode('utf-8')
     except ValueError:
         username = auth_content
         password = ""
     
     # FIXME: Get client cert
     cert = None
     address = (cherrypy.request.remote.ip, cherrypy.request.remote.name)
     return self.authenticate(cert, username, password, address)
def verify_certs_signature(service_id, xml_text, notary_pub_key_text):
	doc = parseString(xml_text)
	root = doc.documentElement
	sig_to_verify = base64.standard_b64decode(root.getAttribute("sig"))
	
	to_verify = service_id
	cert_elements = root.getElementsByTagName("certificate")
	
	for cert_elem in cert_elements:
		cert = base64.standard_b64decode(cert_elem.getAttribute("body"))
		to_verify += cert
		
		start_ts = int(cert_elem.getAttribute("start"))
		end_ts = int(cert_elem.getAttribute("end"))
		to_verify += struct.pack("!2I", start_ts, end_ts)
		
	
	bio = BIO.MemoryBuffer(notary_pub_key_text)
	rsa_pub = RSA.load_pub_key_bio(bio)
	pubkey = EVP.PKey()
	pubkey.assign_rsa(rsa_pub)

	pubkey.reset_context(md='sha256')
	pubkey.verify_init()
	pubkey.verify_update(to_verify)
	return pubkey.verify_final(sig_to_verify)
예제 #8
0
    def loads_from_str(cls, things):

        if not things:
            logging.warning("No data to decode")
            return

        if isinstance(things, str):
            try:
                return pickle.loads(base64.standard_b64decode(bytes(things, encoding=cls.__code__)))
            except Exception as e:
                logging.error("Base64 Format Error! Error data: {}".format(things))
                logging.error(traceback.format_exc())
                return

        elif isinstance(things, bytes):
            try:
                return pickle.loads(base64.standard_b64decode(things))
            except BaseException:
                logging.error('Unpickle error:{}'.format(things))
                logging.error(traceback.format_exc())
                return

        else:
            logging.warning(
                "Decode unknown type data to Object happened exception, type={}, Data={}".format(
                    str(type(things)), str(things))
            )
        return
예제 #9
0
def restore_container_snapshots(container, snapshot):
    """
    Restore the referenced container snapshot.

    Note: Backends may have preconditions before this operation can be run.
    """
    if not isinstance(config.container_backend, SnapshotableContainerBackend):
        return error_precondition_required("Snapshotable backend required")

    try:
        restored_snapshot = config.container_backend.restore_container_snapshot(
            standard_b64decode(container),
            standard_b64decode(snapshot)
        )
        return success_ok(restored_snapshot)
    except ContainerNotFoundError:
        return error_not_found("Container not found")
    except ContainerSnapshotNotFoundError:
        return error_not_found("Container snapshot not found")
    except IllegalContainerStateError:
        return error_precondition_failed("Container in illegal state for requested action")
    except ContainerBackendError:
        return error_unexpected_error("Unexpected backend error")
    except NotImplementedError:
        return error_not_implemented()
    except:
        return error_unexpected_error()
예제 #10
0
파일: SSLServer.py 프로젝트: ab/bcfg2
 def authenticate(self):
     try:
         header = self.headers['Authorization']
     except KeyError:
         self.logger.error("No authentication data presented")
         return False
     auth_type, auth_content = header.split()
     try:
         # py3k compatibility
         auth_content = base64.standard_b64decode(auth_content)
     except TypeError:
         auth_content = base64.standard_b64decode(bytes(auth_content.encode('ascii')))
     try:
         # py3k compatibility
         try:
             username, password = auth_content.split(":")
         except TypeError:
             username, pw = auth_content.split(bytes(":", encoding='utf-8'))
             password = pw.decode('utf-8')
     except ValueError:
         username = auth_content
         password = ""
     cert = self.request.getpeercert()
     client_address = self.request.getpeername()
     return self.server.instance.authenticate(cert, username,
                                              password, client_address)
def get_token():
    #To avoid this function put your api key in ./IXFtoken
    mytempfile = "./IXFtoken"
    if os.path.isfile(mytempfile):
	    tokenf = open(mytempfile,"r")
	    token = tokenf.readline()
	   #Check the API key to see if it is a API key or token, either should work. API Keys are base64 encoded
	    try:
		standard_b64decode(token)
		apiauthheader = "Basic "
	    except TypeError:
		print "Your API key doesn't look right. Go get an API key then use the -a switch to save your user:pass to ./IXFtoken" 
		exit()
    else:
	    print "Support for Anonymous API has been removed. Go get an API key then use the -a switch to save your user:pass to ./IXFtoken"
	    exit ()
	    #When the Anonymous API worked, this code block worked. The authentication header was also different.
	    #url = "https://api.xforce.ibmcloud.com/auth/anonymousToken"
	    #data = urllib2.urlopen(url)
	    #t = json.load(data)
	    #tokenf = open(mytempfile,"w")
            #token = str(t['token'])
            #tokenf.write(token)
	    #apitype = "Bearer "
    return (token,apiauthheader) 
예제 #12
0
    def continue_carve(self, request):
        # First check if we have already received this block
        if request['block_id'] in FILE_CARVE_MAP[request['session_id']]['blocks_received']:
            return

        # Store block data to be reassembled later
        FILE_CARVE_MAP[request['session_id']]['blocks_received'][int(request['block_id'])] = request['data']

        # Are we expecting to receive more blocks?
        if len(FILE_CARVE_MAP[request['session_id']]['blocks_received']) < FILE_CARVE_MAP[request['session_id']]['block_count']:
            return

        # If not, let's reassemble everything
        out_file_name = FILE_CARVE_DIR+FILE_CARVE_MAP[request['session_id']]['carve_guid']

        # Check the first four bytes for the zstd header. If not no
        # compression was used, it's an uncompressed .tar
        if (base64.standard_b64decode(FILE_CARVE_MAP[request['session_id']]['blocks_received'][0])[0:4] == b'\x28\xB5\x2F\xFD'):
            out_file_name +=  '.zst'
        else:
            out_file_name +=  '.tar'
        f = open(out_file_name, 'wb')
        for x in range(0, FILE_CARVE_MAP[request['session_id']]['block_count']):
            f.write(base64.standard_b64decode(FILE_CARVE_MAP[request['session_id']]['blocks_received'][x]))
        f.close()
        debug("File successfully carved to: %s" % out_file_name)
        FILE_CARVE_MAP[request['session_id']] = {}
 def __init__(self, protected_settings, public_settings):
     """
     TODO: we should validate the parameter first
     """
     self.blobs = []
     self.backup_metadata = None
     self.public_config_obj = None
     self.private_config_obj = None
     self.blobs = None
     """
     get the public configuration
     """
     self.commandToExecute = public_settings.get(CommonVariables.command_to_execute)
     self.taskId = public_settings.get(CommonVariables.task_id)
     self.locale = public_settings.get(CommonVariables.locale)
     self.publicObjectStr = public_settings.get(CommonVariables.object_str)
     if(self.publicObjectStr  is not None and self.publicObjectStr != ""):
         decoded_public_obj_string = base64.standard_b64decode(self.publicObjectStr)
         decoded_public_obj_string = decoded_public_obj_string.strip()
         decoded_public_obj_string = decoded_public_obj_string.strip('\'')
         self.public_config_obj = json.loads(decoded_public_obj_string)
         self.backup_metadata = self.public_config_obj['backupMetadata']
     """
     first get the protected configuration
     """
     self.logsBlobUri = protected_settings.get(CommonVariables.logs_blob_uri)
     self.privateObjectStr = protected_settings.get(CommonVariables.object_str)
     if(self.privateObjectStr!=None and self.privateObjectStr != ""):
         decoded_private_obj_string = base64.standard_b64decode(self.privateObjectStr)
         decoded_private_obj_string = decoded_private_obj_string.strip()
         decoded_private_obj_string = decoded_private_obj_string.strip('\'')
         self.private_config_obj = json.loads(decoded_private_obj_string)
         self.blobs = self.private_config_obj['blobSASUri']
예제 #14
0
파일: mzML.py 프로젝트: manor/mz
    def _scan_from_spec_node(self, spec, scan_time):
        '''Gets the mzScan data from a 'spectrum' mzML node. Right now, does some
        error-checking due to the ambiguous nature of mzML's spec--no guarantees
        about what's in the tree.
        '''
        if spec.find('%scvParam[@name="profile spectrum"]' % NS) is not None:
            scan_mode = 'p'
        else:
            scan_mode = 'c'

        array_length = int(spec.get('defaultArrayLength'))

        mz_array = None
        int_array = None

        for bin in spec.iterfind('%sbinaryDataArrayList/%sbinaryDataArray' % (NS*2)):
            if bin.find('%scvParam[@name="64-bit float"]' % NS) is not None:
                fmt = 'd' * array_length
            else:
                fmt = 'f' * array_length

            if bin.find('%scvParam[@name="no compression"]' % NS) is not None:
                compression = False
            else:
                compression = True

            if bin.find('%scvParam[@name="m/z array"]' % NS) is not None:
                if mz_array:
                    print "Overwriting m/z array!?"
                if compression:
                    mz_array = struct.unpack(fmt,
                                             zlib.decompress(base64.standard_b64decode(bin.find('%sbinary' % NS).text)))
                else:
                    mz_array = struct.unpack(fmt,
                                             base64.standard_b64decode(bin.find('%sbinary' % NS).text))
            elif bin.find('%scvParam[@name="intensity array"]' % NS) is not None:
                if int_array:
                    print "Overwriting intensity array!?"
                if compression:
                    int_array = struct.unpack(fmt,
                                              zlib.decompress(base64.standard_b64decode(bin.find('%sbinary' % NS).text)))
                else:
                    int_array = struct.unpack(fmt,
                                              base64.standard_b64decode(bin.find('%sbinary' % NS).text))
            else:
                print ("Found some other kind of binary array in here",
                       [b.get('name') for b in bin.iterfind('%scvParam[@name]' % NS)])

        if (mz_array and int_array):
            return mzScan(zip(mz_array, int_array), scan_time, mode=scan_mode)
        else:
            if mz_array:
                print "No intensity values"
            elif int_array:
                print "No m/z values"
            else:
                print "No m/z or intensity values"
            return None
예제 #15
0
def base64_binary_validator(x):
    match = NOT_BASE64_BINARY_PATTERN.search(x)
    if match is not None:
        reason = "not a base64 encoding: illegal character %r at position %d." % (match.group(0), match.span()[0])
        yield XMLSchemaValidationError(base64_binary_validator, x, reason)
    else:
        try:
            base64.standard_b64decode(x)
        except (ValueError, TypeError) as err:
            yield XMLSchemaValidationError(base64_binary_validator, x, "not a base64 encoding: %s." % err)
    def test_b64decode(self):
        eq = self.assertEqual

        tests = {b"d3d3LnB5dGhvbi5vcmc=": b"www.python.org",
                 b'AA==': b'\x00',
                 b"YQ==": b"a",
                 b"YWI=": b"ab",
                 b"YWJj": b"abc",
                 b"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE"
                 b"RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\nNT"
                 b"Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==":

                 b"abcdefghijklmnopqrstuvwxyz"
                 b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                 b"0123456789!@#0^&*();:<>,. []{}",
                 b'': b'',
                 }
        for data, res in tests.items():
            eq(base64.b64decode(data), res)
            eq(base64.b64decode(data.decode('ascii')), res)
        # Non-bytes
        self.check_other_types(base64.b64decode, b"YWJj", b"abc")
        self.check_decode_type_errors(base64.b64decode)

        # Test with arbitrary alternative characters
        tests_altchars = {(b'01a*b$cd', b'*$'): b'\xd3V\xbeo\xf7\x1d',
                          }
        for (data, altchars), res in tests_altchars.items():
            data_str = data.decode('ascii')
            altchars_str = altchars.decode('ascii')

            eq(base64.b64decode(data, altchars=altchars), res)
            eq(base64.b64decode(data_str, altchars=altchars), res)
            eq(base64.b64decode(data, altchars=altchars_str), res)
            eq(base64.b64decode(data_str, altchars=altchars_str), res)

        # Test standard alphabet
        for data, res in tests.items():
            eq(base64.standard_b64decode(data), res)
            eq(base64.standard_b64decode(data.decode('ascii')), res)
        # Non-bytes
        self.check_other_types(base64.standard_b64decode, b"YWJj", b"abc")
        self.check_decode_type_errors(base64.standard_b64decode)

        # Test with 'URL safe' alternative characters
        tests_urlsafe = {b'01a-b_cd': b'\xd3V\xbeo\xf7\x1d',
                         b'': b'',
                         }
        for data, res in tests_urlsafe.items():
            eq(base64.urlsafe_b64decode(data), res)
            eq(base64.urlsafe_b64decode(data.decode('ascii')), res)
        # Non-bytes
        self.check_other_types(base64.urlsafe_b64decode, b'01a-b_cd',
                               b'\xd3V\xbeo\xf7\x1d')
        self.check_decode_type_errors(base64.urlsafe_b64decode)
예제 #17
0
def verify(signed_data, signature_base64):
    """Returns whether the given data was signed with the private key."""

    h = SHA.new()
    h.update(signed_data)
    # Scheme is RSASSA-PKCS1-v1_5.
    _PUBLIC_KEY = RSA.importKey(base64.standard_b64decode(_PUBLIC_KEY_BASE64))
    verifier = PKCS1_v1_5.new(_PUBLIC_KEY)
    # The signature is base64 encoded.
    signature = base64.standard_b64decode(signature_base64)
    return verifier.verify(h, signature)
예제 #18
0
파일: converter.py 프로젝트: CGTIC/Plone_SP
def b64decode_file(value):
    filename, data = value.split(';')

    filename = filename.split(':')[1]
    filename = base64.standard_b64decode(filename)
    filename = filename.decode('utf-8')

    data = data.split(':')[1]
    data = base64.standard_b64decode(data)

    return filename, data
예제 #19
0
 def _load(self, filename):
     self.log.debug("Loading file %r", filename)
     file = self._File(encode_filename(filename))
     file.tags = file.tags or {}
     metadata = Metadata()
     for origname, values in file.tags.items():
         for value in values:
             name = origname
             if name == "date" or name == "originaldate":
                 # YYYY-00-00 => YYYY
                 value = sanitize_date(value)
             elif name == 'performer' or name == 'comment':
                 # transform "performer=Joe Barr (Piano)" to "performer:Piano=Joe Barr"
                 name += ':'
                 if value.endswith(')'):
                     start = value.rfind(' (')
                     if start > 0:
                         name += value[start + 2:-1]
                         value = value[:start]
             elif name.startswith('rating'):
                 try: name, email = name.split(':', 1)
                 except ValueError: email = ''
                 if email != self.config.setting['rating_user_email']:
                     continue
                 name = '~rating'
                 value = unicode(int(round((float(value) * (self.config.setting['rating_steps'] - 1)))))
             elif name == "fingerprint" and value.startswith("MusicMagic Fingerprint"):
                 name = "musicip_fingerprint"
                 value = value[22:]
             elif name == "tracktotal":
                 if "totaltracks" in file.tags:
                     continue
                 name = "totaltracks"
             elif name == "disctotal":
                 if "totaldiscs" in file.tags:
                     continue
                 name = "totaldiscs"
             elif name == "metadata_block_picture":
                 image = mutagen.flac.Picture(base64.standard_b64decode(value))
                 metadata.add_image(image.mime, image.data)
                 continue
             metadata.add(name, value)
     if self._File == mutagen.flac.FLAC:
         for image in file.pictures:
             metadata.add_image(image.mime, image.data)
     # Read the unofficial COVERART tags, for backward compatibillity only
     if not "metadata_block_picture" in file.tags:
         try:
             for index, data in enumerate(file["COVERART"]):
                 metadata.add_image(file["COVERARTMIME"][index], base64.standard_b64decode(data))
         except KeyError:
             pass
     self._info(metadata, file)
     return metadata
예제 #20
0
 def decrypt( self, b64_data ):
   """
   Requires b64 data separated by # to decrypt
   """
   # TODO: Verify the data and add a try statement?
   salt, iv, cipher_text = b64_data.split('#', 3)
   salt = base64.standard_b64decode(salt)
   iv = base64.standard_b64decode(iv)
   cipher_text = base64.standard_b64decode(cipher_text)
   key = pbkdf2(self.passphrase, salt, ITERATION_COUNT, keylen=KEY_LENGTH)
   cipher = AES.new(key, AES.MODE_CBC, iv )
   return unpad(cipher.decrypt( cipher_text ))
예제 #21
0
    def __perform_key_handshake(self):
        esn = self.nx_common.get_esn()
        self.nx_common.log(msg='perform_key_handshake: esn:' + esn)

        if not esn:
          return False

        header = self.__generate_msl_header(
            is_key_request=True,
            is_handshake=True,
            compressionalgo='',
            encrypt=False)

        request = {
            'entityauthdata': {
                'scheme': 'NONE',
                'authdata': {
                    'identity': esn
                }
            },
            'headerdata': base64.standard_b64encode(header),
            'signature': '',
        }
        #self.nx_common.log(msg='Key Handshake Request:')
        #self.nx_common.log(msg=json.dumps(request))

        try:
            resp = self.session.post(
                url=self.endpoints['manifest'],
                data=json.dumps(request, sort_keys=True))
        except:
            resp = None
            exc = sys.exc_info()
            self.nx_common.log(
                msg='[MSL][POST] Error {} {}'.format(exc[0], exc[1]))

        if resp and resp.status_code == 200:
            resp = resp.json()
            if 'errordata' in resp:
                self.nx_common.log(msg='Key Exchange failed')
                self.nx_common.log(
                    msg=base64.standard_b64decode(resp['errordata']))
                return False
            base_head = base64.standard_b64decode(resp['headerdata'])

            headerdata=json.JSONDecoder().decode(base_head)
            self.__set_master_token(headerdata['keyresponsedata']['mastertoken'])
            self.crypto.parse_key_response(headerdata)
            self.__save_msl_data()
        else:
            self.nx_common.log(msg='Key Exchange failed')
            self.nx_common.log(msg=resp.text)
예제 #22
0
def b64decode_file(value):
    if isinstance(value, six.text_type):
        value = value.encode('utf8')
    filename, data = value.split(b';')

    filename = filename.split(b':')[1]
    filename = base64.standard_b64decode(filename)
    filename = filename.decode('utf-8')

    data = data.split(b':')[1]
    data = base64.standard_b64decode(data)

    return filename, data
예제 #23
0
파일: keestand.py 프로젝트: 912d/code
 def post(self):
   success, user = AuthorizedUser(self.request.cookies)
   if not success:
     self.error(401)
     return
   # We need to store the new salt, password_hash, and encrypted passwords.
   salt = self.request.get("salt")
   assert salt
   user.salt = db.Blob(base64.standard_b64decode(salt))
   password_hash = self.request.get("password_hash")
   user.password_hash = db.ByteString(base64.standard_b64decode(password_hash))
   Save(user, self.request)
   SetUserCookie(self.response, user.username, password_hash)
예제 #24
0
파일: keestand.py 프로젝트: 912d/code
def AuthorizedUser(cookies):
  session = cookies.get("session", "").split(".")
  username = base64.standard_b64decode(session[0])
  password_hash = session[1]
  query = User.all()
  query.filter("username ="******"password_hash =",
               db.ByteString(base64.standard_b64decode(password_hash)))
  user = query.get()
  if not user:
    logging.error("Should never get here! Data received but username (%s) or "
                  "password_hash (%s) is wrong!" % (username, password_hash))
  return user <> None, user
예제 #25
0
파일: crypto.py 프로젝트: pmoor/swiss-vault
def decryptSecret(encryption, secret_key):
  assert encryption["algorithm"] == "AES_256_CBC_HMAC_SHA256"
  iv = base64.standard_b64decode(encryption["iv"])
  ciphertext = base64.standard_b64decode(encryption["ciphertext"])
  signature = base64.standard_b64decode(encryption["signature"])

  cipher = EVP.Cipher(alg="aes_256_cbc", key=secret_key, iv=iv, op=M2Crypto.decrypt)
  value = cipher.update(ciphertext)
  value += cipher.final()

  hmac = EVP.hmac(secret_key, iv + value, algo="sha256")
  if hmac != signature:
    raise Exception("invalid signature")
  return value
예제 #26
0
def recharge_verify(post_sign, post_notify_data, post_orderid, post_dealseq,
                    post_uid, post_subject, post_v):

    if post_sign == "":
        logger.debug(" Unable to get required value")
        return False

    post_sign = base64.standard_b64decode(post_sign)

    # 对输入参数根据参数名排序,并拼接为key=value&key=value格式;
    # sourcestr = "?" + 'notify_data=' + post_notify_data
    # sourcestr += '&orderid=' +  post_orderid
    # sourcestr += '&dealseq=' +  post_dealseq
    # sourcestr += '&uid=' +  post_uid
    # sourcestr += '&subject=' +  post_subject
    # sourcestr += '&v=' +  post_v
    # logger.debug('Raw sign is: %s', sourcestr)

    # 对数据进行验签,注意对公钥做格式转换
    # verify = pub.verify(sourcestr, sig)
    # logger.debug('Verification result is %s', verify)
    # if verify:
    #     logger.debug('Failed to verify data')
    #     return False

    # 对加密的notify_data进行解密
    decode_data = base64.standard_b64decode(post_notify_data)
    decode_notify_data = pub.public_decrypt(decode_data, RSA.pkcs1_padding)

    logger.debug('Notify data decoded as %s', decode_notify_data)

    result = parse_str(decode_notify_data)
    dealseq = result['dealseq']
    fee = result['fee']
    payresult = result['payresult']

    logger.debug('dealseq:%s fee:%s payresult:%s', dealseq, fee, payresult)

    # 比较解密出的数据中的dealseq和参数中的dealseq是否一致
    if dealseq != post_dealseq:
        logger.debug(" Dealseq values did not match:%s-%s",
                     dealseq, post_dealseq)
        return False, 0

    if payresult != '0':
        logger.error("recharge fail payresult:%s", payresult)
        return False, 0

    logger.debug('kuaiyong verify success!')
    return True, fee
예제 #27
0
def admin_delete_video(self,sel,curr_url):
    """Completely delete a video from the site.

    """
    
    vid_id = curr_url.split('/videos/')[1]
    sel.open("/videos/"+vid_id+"staff/delete")
    if sel.is_element_present("id_username"):
        sel.type("id_username", base64.standard_b64decode(testvars.ad_usr))
        sel.type("id_password", base64.standard_b64decode(testvars.del_pw))
        sel.click("//input[@value='Log in']")
        sel.wait_for_page_to_load(testvars.timeout)
    sel.open("/admin/logout")
    time.sleep(5)
    sel.open("/")
예제 #28
0
파일: util.py 프로젝트: nlisgo/h
def basic_auth_creds(request):
    """
    Extract any HTTP Basic authentication credentials for the request.

    Returns a tuple with the HTTP Basic access authentication credentials
    ``(username, password)`` if provided, otherwise ``None``.

    :param request: the request object
    :type request: pyramid.request.Request

    :returns: a tuple of (username, password) or None
    :rtype: tuple or NoneType
    """
    try:
        authtype, value = request.authorization
    except TypeError:  # no authorization header
        return None
    if authtype.lower() != 'basic':
        return None
    try:
        user_pass_bytes = base64.standard_b64decode(value)
    except TypeError:  # failed to decode
        return None
    try:
        # See the lengthy comment in the tests about why we assume UTF-8
        # encoding here.
        user_pass = user_pass_bytes.decode('utf-8')
    except UnicodeError:  # not UTF-8
        return None
    try:
        username, password = user_pass.split(':', 1)
    except ValueError:  # not enough values to unpack
        return None
    return (username, password)
    def _parse_config(self, ctxt):
        config = None
        try:
            config=json.loads(ctxt)
        except:
            self.error('JSON exception decoding ' + ctxt)

        if config is None:
            self.error("JSON error processing settings file:" + ctxt)
        else:
            handlerSettings = config['runtimeSettings'][0]['handlerSettings']
            if handlerSettings.has_key('protectedSettings') and \
                    handlerSettings.has_key("protectedSettingsCertThumbprint") and \
                    handlerSettings['protectedSettings'] is not None and \
                    handlerSettings["protectedSettingsCertThumbprint"] is not None:
                protectedSettings = handlerSettings['protectedSettings']
                thumb=handlerSettings['protectedSettingsCertThumbprint']
                cert=waagent.LibDir+'/'+thumb+'.crt'
                pkey=waagent.LibDir+'/'+thumb+'.prv'
                unencodedSettings = base64.standard_b64decode(protectedSettings)
                openSSLcmd = "openssl smime -inform DER -decrypt -recip {0} -inkey {1}"
                cleartxt = waagent.RunSendStdin(openSSLcmd.format(cert, pkey), unencodedSettings)[1]
                if cleartxt is None:
                    self.error("OpenSSL decode error using  thumbprint " + thumb )
                    self.do_exit(1,"Enable",'error','1', 'Failed to decrypt protectedSettings')
                jctxt=''
                try:
                    jctxt=json.loads(cleartxt)
                except:
                    self.error('JSON exception decoding ' + cleartxt)
                handlerSettings['protectedSettings']=jctxt
                self.log('Config decoded correctly.')
        return config
예제 #30
0
    def results_handler(self, jsondata):
        numMatches = 0
        if 'results' in jsondata:
            if 'qSeq' in jsondata:
                self.wizard.popup_app.win.qSeqs[self.match_id] = str(jsondata['qSeq'])
            if 'matches' in jsondata:
                for index, match in enumerate(jsondata['matches']):
                    # uncompress and decode matches
                    unencoded = base64.standard_b64decode(match)
                    uncompressed = zlib.decompress(unencoded)
                    header = uncompressed.splitlines()[0]
                    phid = re.search('/(.*?).pds', header).group(1).split('/')
                    hid = phid[len(phid)-1] + '.' + str(index)
                    print('found: ' + hid + ' ' + header.split('pds')[1])

                    # load the pdb and group
                    self.cmd.read_pdbstr(str(uncompressed), hid)
                    self.cmd.group(self.match_id, hid)
                    numMatches = numMatches + 1

                self.dictionary[self.match_id] = str(jsondata['tempdir']).split('/')[-1]

        # add current search to search history
        self.setReturn(numMatches)
        if (numMatches):
                    self.cmd.get_wizard().popup_app.add_new_search(self.match_id)
예제 #31
0
파일: __init__.py 프로젝트: sebr/hass-aarlo
    def __init__(self, **kwargs):

        # core values
        self._last_error = None

        # Set up the config first.
        self._cfg = ArloCfg(self, **kwargs)

        # Create storage/scratch directory.
        if self._cfg.state_file is not None or self._cfg.dump_file is not None:
            try:
                os.mkdir(self._cfg.storage_dir)
            except Exception:
                pass

        # Create remaining components.
        self._bg = ArloBackground(self)
        self._st = ArloStorage(self)
        self._be = ArloBackEnd(self)
        self._ml = ArloMediaLibrary(self)

        # Failed to login, then stop now!
        if not self._be.is_connected:
            return

        self._lock = threading.Condition()
        self._bases = []
        self._cameras = []
        self._lights = []
        self._doorbells = []

        # On day flip we do extra work, record today.
        self._today = datetime.date.today()

        # Every few hours we can refresh the device list.
        self._refresh_devices_at = time.monotonic(
        ) + self._cfg.refresh_devices_every

        # default blank image when waiting for camera image to appear
        self._blank_image = base64.standard_b64decode(BLANK_IMAGE)

        # Slow piece.
        # Get devices, fill local db, and create device instance.
        self.info('pyaarlo starting')
        self._started = False
        self._refresh_devices()
        for device in self._devices:
            dname = device.get('deviceName')
            dtype = device.get('deviceType')
            if device.get('state', 'unknown') != 'provisioned':
                self.info('skipping ' + dname + ': state unknown')
                continue

            if dtype == 'basestation' or \
                    device.get('modelId') == 'ABC1000' or dtype == 'arloq' or dtype == 'arloqs' or \
                    device.get('modelId').startswith('AVD1001'):
                self._bases.append(ArloBase(dname, self, device))
            if dtype == 'arlobridge':
                self._bases.append(ArloBase(dname, self, device))
            if dtype == 'camera' or dtype == 'arloq' or dtype == 'arloqs' or \
                    device.get('modelId').startswith('AVD1001'):
                self._cameras.append(ArloCamera(dname, self, device))
            if dtype == 'doorbell':
                self._doorbells.append(ArloDoorBell(dname, self, device))
            if dtype == 'lights':
                self._lights.append(ArloLight(dname, self, device))

        # Save out unchanging stats!
        self._st.set(['ARLO', TOTAL_CAMERAS_KEY], len(self._cameras))
        self._st.set(['ARLO', TOTAL_BELLS_KEY], len(self._doorbells))
        self._st.set(['ARLO', TOTAL_LIGHTS_KEY], len(self._lights))

        # Always ping bases first!
        self._ping_bases()

        # Queue up initial config and state retrieval.
        self.debug('getting initial settings')
        self._bg.run_in(self._refresh_camera_thumbnails, REFRESH_CAMERA_DELAY)
        self._bg.run_in(self._refresh_camera_media, REFRESH_CAMERA_DELAY)
        self._bg.run_in(self._initial_refresh, INITIAL_REFRESH_DELAY)
        self._bg.run_in(self._ml.load, MEDIA_LIBRARY_DELAY)

        # Register house keeping cron jobs.
        self.debug('registering cron jobs')
        self._bg.run_every(self._fast_refresh, FAST_REFRESH_INTERVAL)
        self._bg.run_every(self._slow_refresh, SLOW_REFRESH_INTERVAL)

        # Wait for initial refresh
        if self._cfg.wait_for_initial_setup:
            with self._lock:
                while not self._started:
                    self.debug('waiting for initial setup...')
                    self._lock.wait(5)
            self.debug('finished...')
예제 #32
0
파일: cwa.py 프로젝트: raphaelm/cwa-qr
import base64
from typing import Optional

import qrcode
import secrets
from datetime import datetime

from . import cwa_pb2 as lowlevel

PUBLIC_KEY_STR = 'gwLMzE153tQwAOf2MZoUXXfzWTdlSpfS99iZffmcmxOG9njSK4RTimFOFwDh6t0Tyw8XR01ugDYjtuKwj' \
                 'juK49Oh83FWct6XpefPi9Skjxvvz53i9gaMmUEc96pbtoaA'

PUBLIC_KEY = base64.standard_b64decode(PUBLIC_KEY_STR.encode('ascii'))


class CwaEventDescription(object):
    def __init__(self):
        """Description of the Location, Required, String, max 100 Characters"""
        self.locationDescription: Optional[str] = None

        """Address of the Location, Required, String, max 100 Characters"""
        self.locationAddress: Optional[str] = None

        """Start of the Event, Optional, datetime in UTC"""
        self.startDateTime: Optional[datetime] = None

        """End of the Event, Optional, datetime in UTC"""
        self.endDateTime: Optional[datetime] = None

        """Type of the Location, Optional
예제 #33
0
 def _validate_signature(self, receipt: str, signature: str) -> bool:
     try:
         sig = base64.standard_b64decode(signature)
         return rsa.verify(receipt.encode(), sig, self.public_key)
     except BaseException:
         return False
예제 #34
0
파일: window.py 프로젝트: gibfahn/kitty
 def handle_remote_print(self, msg):
     from base64 import standard_b64decode
     msg = standard_b64decode(msg).decode('utf-8')
     print(msg, end='', file=sys.stderr)
     sys.stderr.flush()
예제 #35
0
    benchmark(fn)


def _test_digest(digest):
    assert digest.K == 100
    assert digest.n == 100000
    assert len(digest) == 1083
    assert digest.percentile(50) - 0.5 < 0.02
    assert digest.percentile(10) - 0.1 < 0.01
    assert digest.percentile(90) - 0.9 < 0.01
    assert digest.percentile(1) - 0.01 < 0.005
    assert digest.percentile(99) - 0.99 < 0.005
    assert digest.percentile(0.1) - 0.001 < 0.001
    assert digest.percentile(99.9) - 0.999 < 0.001


def test_tdigest_as_bytes():
    digest = from_bytes(java_bytes)
    b = as_bytes(digest)

    digest = from_bytes(b)
    _test_digest(digest)

    assert len(b) == len(java_bytes)
    assert b == java_bytes


# pylint: disable=line-too-long
java_base64 = "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"
java_bytes = base64.standard_b64decode(java_base64)
예제 #36
0
def rpc_call_rlp(ssl_sock, method, params, default_timeout=False):
    for (key, val) in params.items():
        params[key] = base64.standard_b64encode(val).decode()
    result = rpc_call(ssl_sock, method, params, default_timeout)
    return base64.standard_b64decode(result.encode()) if result else None
예제 #37
0
    exponent = bits[1:12]
    mantissa = bits[12:64]
    mantissa_value = sum([(1 / 2)**(bit_num + 1) * int(mantissa[bit_num])
                          for bit_num in range(0, 52)])
    exponent = int(exponent, base=2)
    return (1 + mantissa_value) * 2**(exponent - 1023)


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('-t', '--token', required=True)
    args = parser.parse_args()
    json_input = urllib.request.urlopen(
        f'{PROBLEM_URL}/problem?access_token={args.token}')
    b64_bytes_input = json.loads(json_input.read())['bytes']
    raw_bytes = base64.standard_b64decode(b64_bytes_input)
    raw_bits = [b[2:].rjust(8, '0') for b in map(bin, bytearray(raw_bytes))]
    bit_blob = ''.join(raw_bits)
    # int is 32-bit wide
    int_part = bit_blob[0:32]
    # uint is also 32-bit wide
    uint_part = bit_blob[32:64]
    # short is 16-bit wide, but right after it there's 16 bits of whitespace (?)
    short_part = bit_blob[64:80]
    # float is 32-bit wide
    float_part = bit_blob[96:128]
    # double is 64-bit wide
    double_part = bit_blob[128:192]
    # big endian(ed) double is also 64-bit wide
    big_endian_double_part = bit_blob[192:256]
    results = {
예제 #38
0
import os
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

# Padding
from cryptography.hazmat.primitives import padding

import socket
from threading import Thread, Event

mysock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# mysock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
mysock.bind((socket.gethostname(), os.getenv('PORT', 8500)))
mysock.listen(5)

# Setting up the cryptography
env_publickey = base64.standard_b64decode(os.environ['HIS_PUBLICKEY'].encode(
    encoding="utf-8", errors="strict"))
loaded_public_key = X25519PublicKey.from_public_bytes(env_publickey)
env_private_key = base64.standard_b64decode(os.environ['PRIVATEKEY'].encode(
    encoding="utf-8", errors="strict"))
private_key = X25519PrivateKey.from_private_bytes(env_private_key)
shared_key = private_key.exchange(loaded_public_key)
# Perform key derivation.
derived_key = HKDF(
    algorithm=hashes.SHA256(),
    length=32,
    salt=None,
    info=b'handshake data',
).derive(shared_key)
HMAC_key = HKDF(
    algorithm=hashes.SHA256(),
    length=32,
예제 #39
0
def b64_to_hex_id(id_string):
    return binascii.hexlify(base64.standard_b64decode(
        str(id_string))).decode("utf-8")
예제 #40
0
def _authenticate_scram(credentials, sock_info, mechanism):
    """Authenticate using SCRAM."""
    username = credentials.username
    if mechanism == 'SCRAM-SHA-256':
        digest = "sha256"
        digestmod = hashlib.sha256
        data = saslprep(credentials.password).encode("utf-8")
    else:
        digest = "sha1"
        digestmod = hashlib.sha1
        data = _password_digest(username, credentials.password).encode("utf-8")
    source = credentials.source
    cache = credentials.cache

    # Make local
    _hmac = hmac.HMAC

    ctx = sock_info.auth_ctx.get(credentials)
    if ctx and ctx.speculate_succeeded():
        nonce, first_bare = ctx.scram_data
        res = ctx.speculative_authenticate
    else:
        nonce, first_bare, cmd = _authenticate_scram_start(
            credentials, mechanism)
        res = sock_info.command(source, cmd)

    server_first = res['payload']
    parsed = _parse_scram_response(server_first)
    iterations = int(parsed[b'i'])
    if iterations < 4096:
        raise OperationFailure("Server returned an invalid iteration count.")
    salt = parsed[b's']
    rnonce = parsed[b'r']
    if not rnonce.startswith(nonce):
        raise OperationFailure("Server returned an invalid nonce.")

    without_proof = b"c=biws,r=" + rnonce
    if cache.data:
        client_key, server_key, csalt, citerations = cache.data
    else:
        client_key, server_key, csalt, citerations = None, None, None, None

    # Salt and / or iterations could change for a number of different
    # reasons. Either changing invalidates the cache.
    if not client_key or salt != csalt or iterations != citerations:
        salted_pass = _hi(digest, data, standard_b64decode(salt), iterations)
        client_key = _hmac(salted_pass, b"Client Key", digestmod).digest()
        server_key = _hmac(salted_pass, b"Server Key", digestmod).digest()
        cache.data = (client_key, server_key, salt, iterations)
    stored_key = digestmod(client_key).digest()
    auth_msg = b",".join((first_bare, server_first, without_proof))
    client_sig = _hmac(stored_key, auth_msg, digestmod).digest()
    client_proof = b"p=" + standard_b64encode(_xor(client_key, client_sig))
    client_final = b",".join((without_proof, client_proof))

    server_sig = standard_b64encode(
        _hmac(server_key, auth_msg, digestmod).digest())

    cmd = SON([('saslContinue', 1), ('conversationId', res['conversationId']),
               ('payload', Binary(client_final))])
    res = sock_info.command(source, cmd)

    parsed = _parse_scram_response(res['payload'])
    if not compare_digest(parsed[b'v'], server_sig):
        raise OperationFailure("Server returned an invalid signature.")

    # A third empty challenge may be required if the server does not support
    # skipEmptyExchange: SERVER-44857.
    if not res['done']:
        cmd = SON([('saslContinue', 1),
                   ('conversationId', res['conversationId']),
                   ('payload', Binary(b''))])
        res = sock_info.command(source, cmd)
        if not res['done']:
            raise OperationFailure('SASL conversation failed to complete.')
예제 #41
0
    def process_song(self, root, file_path):
        """
        :param root:
        :param pathlib.Path file_path: Path to the file thats being imported
        :rtype: None
        """
        self.set_defaults()

        # Extract ProPresenter versionNumber
        try:
            self.version = int(root.get('versionNumber'))
        except (ValueError, TypeError):
            log.debug('ProPresenter versionNumber invalid or missing')
            return

        # Title
        self.title = root.get('CCLISongTitle')
        if not self.title or self.title == '':
            self.title = file_path.stem
        # Notes
        self.comments = root.get('notes')
        # Author
        for author_key in [
                'author', 'CCLIAuthor', 'artist', 'CCLIArtistCredits'
        ]:
            author = root.get(author_key)
            if author and len(author) > 0:
                self.parse_author(author)

        # ProPresenter 4
        if 400 <= self.version < 500:
            self.copyright = root.get('CCLICopyrightInfo')
            self.ccli_number = root.get('CCLILicenseNumber')
            count = 0
            for slide in root.slides.RVDisplaySlide:
                count += 1
                if not hasattr(slide.displayElements, 'RVTextElement'):
                    log.debug('No text found, may be an image slide')
                    continue
                RTFData = slide.displayElements.RVTextElement.get('RTFData')
                rtf = base64.standard_b64decode(RTFData)
                words, encoding = strip_rtf(rtf.decode())
                self.add_verse(words, "v{count}".format(count=count))

        # ProPresenter 5
        elif 500 <= self.version < 600:
            self.copyright = root.get('CCLICopyrightInfo')
            self.ccli_number = root.get('CCLILicenseNumber')
            count = 0
            for group in root.groups.RVSlideGrouping:
                for slide in group.slides.RVDisplaySlide:
                    count += 1
                    if not hasattr(slide.displayElements, 'RVTextElement'):
                        log.debug('No text found, may be an image slide')
                        continue
                    RTFData = slide.displayElements.RVTextElement.get(
                        'RTFData')
                    rtf = base64.standard_b64decode(RTFData)
                    words, encoding = strip_rtf(rtf.decode())
                    self.add_verse(words, "v{count:d}".format(count=count))

        # ProPresenter 6
        elif 600 <= self.version < 700:
            self.copyright = root.get('CCLICopyrightYear')
            self.ccli_number = root.get('CCLISongNumber')
            count = 0
            for group in root.array.RVSlideGrouping:
                for slide in group.array.RVDisplaySlide:
                    count += 1
                    for item in slide.array:
                        if not (item.get('rvXMLIvarName')
                                == "displayElements"):
                            continue
                        if not hasattr(item, 'RVTextElement'):
                            log.debug('No text found, may be an image slide')
                            continue
                        for contents in item.RVTextElement.NSString:
                            b64Data = contents.text
                            data = base64.standard_b64decode(b64Data)
                            words = None
                            if contents.get('rvXMLIvarName') == "RTFData":
                                words, encoding = strip_rtf(data.decode())
                                break
                        if words:
                            self.add_verse(words,
                                           "v{count:d}".format(count=count))

        if not self.finish():
            self.log_error(self.import_source)
예제 #42
0
import email_grade
from getpass import getpass
import sys
import time
import config
import subprocess
import quopri
import base64

if __name__ == '__main__':

    #eg = email_grade.EmailGrade('twentyoneguns')
    #print(str(eg.email_list()))

    #     sample = '''/**\r\n     * A simple method that returns a string with a hello world message.\r\n     * @return The string "Hello World!!!".\r\n     */\r\n    public static String helloWorld(){\r\n        return "Hello World!!!";\r\n    }\r\n'''
    #     print(eg._grade(assignmentname = config.assignmentname, email_body = sample, methodname = config.method))

    sample = '''/*** Something
*/
public static String helloWorld(){ return "Correct String=
!";
}'''
    decoded = quopri.decodestring(sample)
    print("quopri decoded: " + str(decoded))
    decodedx2 = decoded.decode("utf-8")
    print("decoded quopri: " + decodedx2)

    b64decode = base64.standard_b64decode(sample)
    print("decoded b64: " + b64decode)
예제 #43
0
    def __init__(self, **kwargs):
        """Constructor for the PyArlo object.
        """
        # core values
        self._last_error = None

        # Set up the config first.
        self._cfg = ArloCfg(self, **kwargs)

        # Create storage/scratch directory.
        if self._cfg.state_file is not None or self._cfg.dump_file is not None:
            try:
                os.mkdir(self._cfg.storage_dir)
            except Exception:
                pass

        # Create remaining components.
        self._bg = ArloBackground(self)
        self._st = ArloStorage(self)
        self._be = ArloBackEnd(self)
        self._ml = ArloMediaLibrary(self)

        # Failed to login, then stop now!
        if not self._be.is_connected:
            return

        self._lock = threading.Condition()
        self._bases = []
        self._cameras = []
        self._lights = []
        self._doorbells = []

        # On day flip we do extra work, record today.
        self._today = datetime.date.today()

        # Every few hours we can refresh the device list.
        self._refresh_devices_at = time.monotonic() + self._cfg.refresh_devices_every

        # default blank image when waiting for camera image to appear
        self._blank_image = base64.standard_b64decode(BLANK_IMAGE)

        # Slow piece.
        # Get devices, fill local db, and create device instance.
        self.info('pyaarlo starting')
        self._started = False
        self._refresh_devices()
        for device in self._devices:
            dname = device.get('deviceName')
            dtype = device.get('deviceType')
            if device.get('state', 'unknown') != 'provisioned':
                self.info('skipping ' + dname + ': state unknown')
                continue

            # This needs it's own code now... Does no parent indicate a base station???
            if dtype == 'basestation' or \
                    device.get('modelId') == 'ABC1000' or dtype == 'arloq' or dtype == 'arloqs' or \
                    device.get("modelId").startswith("FB1001A"):
                self._bases.append(ArloBase(dname, self, device))
            # video doorbell can be its own base station, it can also be assigned to a real base station
            if device.get('modelId').startswith('AVD1001'):
                parent_id = device.get('parentId', None)
                if parent_id is None or parent_id == device.get('deviceId', None):
                    self._bases.append(ArloBase(dname, self, device))
            if dtype == 'arlobridge':
                self._bases.append(ArloBase(dname, self, device))
            if dtype == 'camera' or dtype == 'arloq' or dtype == 'arloqs' or \
                    device.get('modelId').startswith('AVD1001'):
                self._cameras.append(ArloCamera(dname, self, device))
            if dtype == 'doorbell':
                self._doorbells.append(ArloDoorBell(dname, self, device))
            if dtype == 'lights':
                self._lights.append(ArloLight(dname, self, device))

        # Save out unchanging stats!
        self._st.set(['ARLO', TOTAL_CAMERAS_KEY], len(self._cameras))
        self._st.set(['ARLO', TOTAL_BELLS_KEY], len(self._doorbells))
        self._st.set(['ARLO', TOTAL_LIGHTS_KEY], len(self._lights))

        # Always ping bases first!
        self._ping_bases()

        # Initial config and state retrieval.
        if self._cfg.synchronous_mode:
            # Synchronous; run them one after the other
            self.debug('getting initial settings')
            self._refresh_bases(initial=True)
            self._refresh_ambient_sensors()
            self._ml.load()
            self._refresh_camera_thumbnails(True)
            self._refresh_camera_media(True)
            self._initial_refresh_done()
        else:
            # Asynchronous; queue them to run one after the other
            self.debug('queueing initial settings')
            self._bg.run(self._refresh_bases, initial=True)
            self._bg.run(self._refresh_ambient_sensors)
            self._bg.run(self._ml.load)
            self._bg.run(self._refresh_camera_thumbnails, wait=False)
            self._bg.run(self._refresh_camera_media, wait=False)
            self._bg.run(self._initial_refresh_done)

        # Register house keeping cron jobs.
        self.debug('registering cron jobs')
        self._bg.run_every(self._fast_refresh, FAST_REFRESH_INTERVAL)
        self._bg.run_every(self._slow_refresh, SLOW_REFRESH_INTERVAL)

        # Wait for initial refresh
        if self._cfg.wait_for_initial_setup:
            with self._lock:
                while not self._started:
                    self.debug('waiting for initial setup...')
                    self._lock.wait(1)
            self.debug('setup finished...')
예제 #44
0
 def _validate_signature(self, receipt, signature):
     try:
         sig = base64.standard_b64decode(signature)
         return rsa.verify(receipt.encode(), sig, self.public_key)
     except (rsa.VerificationError, TypeError):
         return False
예제 #45
0
def load_pem(contents, pem_marker):
    """Loads a PEM file.

    :param contents: the contents of the file to interpret
    :param pem_marker: the marker of the PEM content, such as 'RSA PRIVATE KEY'
        when your file has '-----BEGIN RSA PRIVATE KEY-----' and
        '-----END RSA PRIVATE KEY-----' markers.

    :return: the base64-decoded content between the start and end markers.

    @raise ValueError: when the content is invalid, for example when the start
        marker cannot be found.

    """

    # We want bytes, not text. If it's text, it can be converted to ASCII bytes.
    if not is_bytes(contents):
        contents = contents.encode('ascii')

    (pem_start, pem_end) = _markers(pem_marker)

    pem_lines = []
    in_pem_part = False

    for line in contents.splitlines():
        line = line.strip()

        # Skip empty lines
        if not line:
            continue

        # Handle start marker
        if line == pem_start:
            if in_pem_part:
                raise ValueError('Seen start marker "%s" twice' % pem_start)

            in_pem_part = True
            continue

        # Skip stuff before first marker
        if not in_pem_part:
            continue

        # Handle end marker
        if in_pem_part and line == pem_end:
            in_pem_part = False
            break

        # Load fields
        if b':' in line:
            continue

        pem_lines.append(line)

    # Do some sanity checks
    if not pem_lines:
        raise ValueError('No PEM start marker "%s" found' % pem_start)

    if in_pem_part:
        raise ValueError('No PEM end marker "%s" found' % pem_end)

    # Base64-decode the contents
    pem = b''.join(pem_lines)
    return base64.standard_b64decode(pem)
예제 #46
0
    def test_b64decode(self):
        eq = self.assertEqual

        tests = {
            b"d3d3LnB5dGhvbi5vcmc=":
            b"www.python.org",
            b'AA==':
            b'\x00',
            b"YQ==":
            b"a",
            b"YWI=":
            b"ab",
            b"YWJj":
            b"abc",
            b"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNE"
            b"RUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\nNT"
            b"Y3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==":
            b"abcdefghijklmnopqrstuvwxyz"
            b"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
            b"0123456789!@#0^&*();:<>,. []{}",
            b'':
            b'',
        }
        for data, res in tests.items():
            eq(base64.b64decode(data), res)
            eq(base64.b64decode(data.decode('ascii')), res)
        # Non-bytes
        self.check_other_types(base64.b64decode, b"YWJj", b"abc")
        self.check_decode_type_errors(base64.b64decode)

        # Test with arbitrary alternative characters
        tests_altchars = {
            (b'01a*b$cd', b'*$'): b'\xd3V\xbeo\xf7\x1d',
        }
        for (data, altchars), res in tests_altchars.items():
            data_str = data.decode('ascii')
            altchars_str = altchars.decode('ascii')

            eq(base64.b64decode(data, altchars=altchars), res)
            eq(base64.b64decode(data_str, altchars=altchars), res)
            eq(base64.b64decode(data, altchars=altchars_str), res)
            eq(base64.b64decode(data_str, altchars=altchars_str), res)

        # Test standard alphabet
        for data, res in tests.items():
            eq(base64.standard_b64decode(data), res)
            eq(base64.standard_b64decode(data.decode('ascii')), res)
        # Non-bytes
        self.check_other_types(base64.standard_b64decode, b"YWJj", b"abc")
        self.check_decode_type_errors(base64.standard_b64decode)

        # Test with 'URL safe' alternative characters
        tests_urlsafe = {
            b'01a-b_cd': b'\xd3V\xbeo\xf7\x1d',
            b'': b'',
        }
        for data, res in tests_urlsafe.items():
            eq(base64.urlsafe_b64decode(data), res)
            eq(base64.urlsafe_b64decode(data.decode('ascii')), res)
        # Non-bytes
        self.check_other_types(base64.urlsafe_b64decode, b'01a-b_cd',
                               b'\xd3V\xbeo\xf7\x1d')
        self.check_decode_type_errors(base64.urlsafe_b64decode)
예제 #47
0
def rpc_param_decode(param):
    return base64.standard_b64decode(param.encode())
예제 #48
0
파일: vorbis.py 프로젝트: bovirus/picard
    def _load(self, filename):
        log.debug("Loading file %r", filename)
        file = self._File(encode_filename(filename))
        file.tags = file.tags or {}
        metadata = Metadata()
        for origname, values in file.tags.items():
            for value in values:
                name = origname
                if name == "date" or name == "originaldate":
                    # YYYY-00-00 => YYYY
                    value = sanitize_date(value)
                elif name == 'performer' or name == 'comment':
                    # transform "performer=Joe Barr (Piano)" to "performer:Piano=Joe Barr"
                    name += ':'
                    if value.endswith(')'):
                        start = len(value) - 2
                        count = 1
                        while count > 0 and start > 0:
                            if value[start] == ')':
                                count += 1
                            elif value[start] == '(':
                                count -= 1
                            start -= 1
                        if start > 0:
                            name += value[start + 2:-1]
                            value = value[:start]
                elif name.startswith('rating'):
                    try:
                        name, email = name.split(':', 1)
                    except ValueError:
                        email = ''
                    if email != sanitize_key(
                            config.setting['rating_user_email']):
                        continue
                    name = '~rating'
                    try:
                        value = str(
                            round((float(value) *
                                   (config.setting['rating_steps'] - 1))))
                    except ValueError:
                        log.warning('Invalid rating value in %r: %s', filename,
                                    value)
                elif name == "fingerprint" and value.startswith(
                        "MusicMagic Fingerprint"):
                    name = "musicip_fingerprint"
                    value = value[22:]
                elif name == "tracktotal":
                    if "totaltracks" in file.tags:
                        continue
                    name = "totaltracks"
                elif name == "disctotal":
                    if "totaldiscs" in file.tags:
                        continue
                    name = "totaldiscs"
                elif name == "metadata_block_picture":
                    image = mutagen.flac.Picture(
                        base64.standard_b64decode(value))
                    try:
                        coverartimage = TagCoverArtImage(
                            file=filename,
                            tag=name,
                            types=types_from_id3(image.type),
                            comment=image.desc,
                            support_types=True,
                            data=image.data,
                        )
                    except CoverArtImageError as e:
                        log.error('Cannot load image from %r: %s' %
                                  (filename, e))
                    else:
                        metadata.images.append(coverartimage)

                    continue
                elif name in self.__translate:
                    name = self.__translate[name]
                metadata.add(name, value)
        if self._File == mutagen.flac.FLAC:
            for image in file.pictures:
                try:
                    coverartimage = TagCoverArtImage(
                        file=filename,
                        tag='FLAC/PICTURE',
                        types=types_from_id3(image.type),
                        comment=image.desc,
                        support_types=True,
                        data=image.data,
                    )
                except CoverArtImageError as e:
                    log.error('Cannot load image from %r: %s' % (filename, e))
                else:
                    metadata.images.append(coverartimage)

        # Read the unofficial COVERART tags, for backward compatibility only
        if "metadata_block_picture" not in file.tags:
            try:
                for data in file["COVERART"]:
                    try:
                        coverartimage = TagCoverArtImage(
                            file=filename,
                            tag='COVERART',
                            data=base64.standard_b64decode(data))
                    except CoverArtImageError as e:
                        log.error('Cannot load image from %r: %s' %
                                  (filename, e))
                    else:
                        metadata.images.append(coverartimage)
            except KeyError:
                pass
        self._info(metadata, file)
        return metadata
예제 #49
0
def decode_component(x):
    return standard_b64decode(x).decode('utf-8')
예제 #50
0
def decode_base64(data):
    missing_padding = len(data) % 4
    if missing_padding != 0:
        data += '=' * (4 - missing_padding)
    return base64.standard_b64decode(data)
예제 #51
0
def recover_transmission(string, simple=False):
    if not simple:
        return base64.standard_b64decode(string[:(len(string) //
                                                  2)].encode(ENCODING))
    else:
        return base64.standard_b64decode(string)
예제 #52
0
 def tokenBase64(self, encodedToken):
     """
     Add deviceToken as base64 encoded string (not binary)
     """
     self.deviceToken = base64.standard_b64decode(encodedToken)
     return self
예제 #53
0
    def decodeBussinessApp(html, iframeReferer):
        #print html
        response = ""

        jsFile = "http://www.businessapp1.pw/jwplayer5/addplayer/jwplayer.js"
        if html.find("jwplayer5/addplayer/jwplayer.js") > -1:
            jsFile = Decoder.rExtractWithRegex(
                "http://", "jwplayer5/addplayer/jwplayer.js", html)
            logger.info("updated js player to: " + jsFile)
        elif html.find("http://www.playerhd1.pw") > -1:
            jsFile = "http://www.playerhd1.pw/jwplayer5/addplayer/jwplayer.js"
        token = ""
        try:
            token = Decoder.extractBusinessappToken(iframeReferer, jsFile)
        except:
            logger.error("Error, trying without token")
            pass

        swfUrl = "http://www.businessapp1.pw/jwplayer5/addplayer/jwplayer.flash.swf"
        if html.find(
                "jwplayer5/addplayer/jwplayer.flash.swf"
        ) > -1:  #http://www.playerapp1.pw/jwplayer5/addplayer/jwplayer.flash.swf
            swfUrl = Decoder.rExtractWithRegex(
                "http://", "jwplayer5/addplayer/jwplayer.flash.swf", html)
            logger.info("updated swf player to: " + swfUrl)
        elif jsFile.find("businessapp1.pw") == -1:
            swfUrl = "http://" + Decoder.extract(
                '//', "/", jsFile) + "/jwplayer5/addplayer/jwplayer.flash.swf"
            logger.info("updated swf player to: " + swfUrl)
        elif html.find("http://www.playerhd1.pw") > -1:
            swfUrl = "http://www.playerhd1.pw/jwplayer5/addplayer/jwplayer.flash.swf"

        if html.find('<input type="hidden" id="ssx1" value="') > -1:
            ssx1 = Decoder.extract('<input type="hidden" id="ssx1" value="',
                                   '"', html)
            ssx4 = Decoder.extract('<input type="hidden" id="ssx4" value="',
                                   '"', html)
            escaped = Decoder.extract(
                "<script type='text/javascript'>document.write(unescape('",
                "'", html)
            unescaped = urllib.unquote(escaped)
            decodedssx1 = base64.standard_b64decode(ssx1)
            decodedssx4 = base64.standard_b64decode(ssx4)
            #print "decoded{"+decodedssx1+","+decodedssx4+"} unescaped: "+unescaped
            iframeReferer = urllib.unquote_plus(
                iframeReferer.replace("+", "@#@")).replace(
                    "@#@", "+")  #unquote_plus replaces '+' characters
            if decodedssx4.find(".m3u8") > -1:
                logger.info("Found simple link: " + decodedssx4)
                response = Decoder.getContent(decodedssx4, "",
                                              iframeReferer).read()
                if response.find("chunklist.m3u8") > -1:
                    finalSimpleLink2 = decodedssx4[:decodedssx4.rfind("/") +
                                                   1] + "chunklist.m3u8"
                    response = Decoder.getContent(finalSimpleLink2, "",
                                                  iframeReferer).read()
                    logger.debug("response for m3u8(1): " + response)
                    response = finalSimpleLink2 + "|Referer=" + iframeReferer
                else:
                    logger.debug("response for m3u8(2): " + response)
                    response = decodedssx4
            elif token != "" and decodedssx4.find("vod/?token=") > -1:
                app = decodedssx4[decodedssx4.find("vod/?token="):]
                response = decodedssx4 + " playpath=" + decodedssx1 + " app=" + app + " swfUrl=" + swfUrl + " token=" + token + " flashver=WIN/2019,0,0,226 live=true timeout=14 pageUrl=" + iframeReferer
            elif token != "":
                app = decodedssx4[decodedssx4.find("redirect/?token="):]
                response = decodedssx4 + " playpath=" + decodedssx1 + " app=" + app + " swfUrl=" + swfUrl + " token=" + token + " flashver=WIN/2019,0,0,226 live=true timeout=14 pageUrl=" + iframeReferer
            else:  #m3u8 file
                logger.info("link1: " + decodedssx1)
                logger.info("link2: " + decodedssx4)
            logger.info("to player: " + response)
        else:
            playPath = ""
            rtmpValue = ""
            #i = 0
            finalSimpleLink = ""
            for splittedHtml in html.split('<input type="hidden" id="'):
                if splittedHtml.find(
                        "DOCTYPE html PUBLIC") == -1 and splittedHtml.find(
                            ' value=""') == -1:
                    #logger.info("processing hidden: "+splittedHtml)
                    extracted = splittedHtml[splittedHtml.find('value="') +
                                             len('value="'):]
                    extracted = extracted[0:extracted.find('"')]
                    logger.info("extracted hidden value: " + extracted)
                    if playPath == "":
                        playPath = base64.standard_b64decode(extracted)
                    else:
                        rtmpValue = base64.standard_b64decode(extracted)
                    decodedAndExtracted = base64.standard_b64decode(extracted)
                    logger.info("original: " + extracted + ", extracted: " +
                                decodedAndExtracted)
                    if decodedAndExtracted.find(".m3u8") > -1:
                        finalSimpleLink = decodedAndExtracted
                #i+=1
            if finalSimpleLink != "":
                logger.info("Found simple link: " + finalSimpleLink)
                response = Decoder.getContent(finalSimpleLink, "",
                                              iframeReferer).read()
                if response.find("chunklist.m3u8") > -1:
                    finalSimpleLink2 = finalSimpleLink[:finalSimpleLink.
                                                       rfind("/") +
                                                       1] + "chunklist.m3u8"
                    response = Decoder.getContent(finalSimpleLink2, "",
                                                  iframeReferer).read()
                    logger.debug("response for m3u8(a): " + response)
                    response = finalSimpleLink2 + "|Referer=" + iframeReferer
                else:
                    logger.debug("response for m3u8(b): " + response)
                    response = finalSimpleLink
            elif rtmpValue.find("vod/?token=") > -1:
                app = rtmpValue[rtmpValue.find("vod/?token="):]
                iframeReferer = urllib.unquote_plus(
                    iframeReferer.replace("+", "@#@")).replace(
                        "@#@", "+")  #unquote_plus replaces '+' characters
                token = Decoder.extractBusinessappToken(iframeReferer, jsFile)
                response = rtmpValue + " playpath=" + playPath + " app=" + app + " swfUrl=" + swfUrl + " token=" + token + " flashver=WIN/2019,0,0,226 live=true timeout=14 pageUrl=" + iframeReferer
            else:
                app = "redirect" + rtmpValue[rtmpValue.find("?token=play@"):]
                token = Decoder.extractBusinessappToken(iframeReferer, jsFile)
                response = rtmpValue + " playpath=" + playPath + " app=" + app + " swfUrl=" + swfUrl + " token=" + token + " flashver=WIN/2019,0,0,226 live=true timeout=14 pageUrl=" + iframeReferer
        return response
예제 #54
0
def unpack_data(data):
    data = data.encode('utf-8')
    data = base64.standard_b64decode(data)
    return data.rstrip("\0")
 def set_cert_from_base64(self, content_base64):
     try:
         raw = base64.standard_b64decode(str(content_base64))
     except (TypeError, binascii.Error):
         raise Exception('The provided certificate is not Base64-encoded')
     self.set_cert_from_raw(raw)
예제 #56
0
            status = 200

        self.send_response(status)
        for key, value in headers.items():
            self.send_header(key, value)
        self.end_headers()
        self.wfile.write(output)


DATA_JPG = base64.standard_b64decode("""
/9j/4AAQSkZJRgABAQEASABIAAD/2wBD
AAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
AQEBAQEBAQEBAQEBAQEBAQH/2wBDAQEB
AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
AQEBAQEBAQEBAQEBAQH/wAARCAABAAED
AREAAhEBAxEB/8QAFAABAAAAAAAAAAAA
AAAAAAAACv/EABQQAQAAAAAAAAAAAAAA
AAAAAAD/xAAUAQEAAAAAAAAAAAAAAAAA
AAAA/8QAFBEBAAAAAAAAAAAAAAAAAAAA
AP/aAAwDAQACEQMRAD8AfwD/2Q==""")

DATA_PNG = base64.standard_b64decode("""
iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB
CAAAAAA6fptVAAAACklEQVQIHWP4DwAB
AQEANl9ngAAAAABJRU5ErkJggg==""")

DATA_GIF = base64.standard_b64decode("""
R0lGODdhAQABAIAAAP///////ywAAAAA
AQABAAACAkQBADs=""")
예제 #57
0
import os
import base64
import json


etcd_file=open("etcd_data.txt","r")
etcd_data=json.load(etcd_file)

for data in etcd_data["kvs"]:
    key,value=data["key"],data["value"]
    key=base64.standard_b64decode(key)
    value=base64.standard_b64decode(value)
    if value.startswith("-"):
        os.system(
            "ETCDCTL_API=3 /home/qboxserver/ava-etcd/_package/etcdctl  --endpoints=http://10.200.20.87:2379,http://10.200.20.89:2379,http://10.200.20.90:2379  put " + key + " -- '" + value + "'")
        continue

    os.system("ETCDCTL_API=3 /home/qboxserver/ava-etcd/_package/etcdctl  --endpoints=http://10.200.20.87:2379,http://10.200.20.89:2379,http://10.200.20.90:2379  put "+key+" '"+value+"'")



root="/Users/cj/qiniu/deploy-test/playbook/ava-serving/apps"
apps=($(ls apps | xargs))
for app in $apps; do sed '' -i 's/http:\/\/10.200.30.13:2379,http:\/\/10.200.30.14:2379,http:\/\/10.200.30.15:2379/http:\/\/10.200.20.87:2379,http:\/\/10.200.20.89:2379,http:\/\/10.200.20.90:2379/' $root/$app/app.yaml; done
예제 #58
0
    def process_frame(self, numbered_datum):
        start_time = time.time()
        frame_data = None
        raw_image = None

        try:
            json_time = 0
            featurization_time = 0
            thumbnail_time = 0
            interframe_time = 0

            frame_number, datum = numbered_datum
            frame_data = json.loads(datum.decode('utf-8'))
            if frame_number is not None:
                frame_data['frameNumber'] = frame_number

            image_rows = 0
            image_cols = 0
            has_raw_image = "rawImage" in frame_data.keys()
            has_thumbnail = "thumbnail" in frame_data.keys()
            raw_image = None

            if has_raw_image:
                image_rows = frame_data["rawImage"]["rows"]
                image_cols = frame_data["rawImage"]["columns"]

                image_bytes = base64.standard_b64decode(
                    frame_data["rawImage"]["binary"])
                image_array = numpy.frombuffer(image_bytes, dtype=numpy.uint8)
                raw_image = numpy.reshape(image_array,
                                          (image_rows, image_cols, 3))

                del frame_data["rawImage"]

                if not has_thumbnail:
                    thumb_start_time = time.time()
                    resized_image = cv2.resize(raw_image, (240, 135))
                    r, buf = cv2.imencode('.jpg', resized_image,
                                          [int(cv2.IMWRITE_JPEG_QUALITY), 50])
                    frame_data['thumbnail'] = {
                        'binary':
                        base64.standard_b64encode(buf).decode('ascii'),
                        'originalCols': image_cols,
                        'originalRows': image_rows
                    }

                    thumbnail_time = time.time() - thumb_start_time

            elif has_thumbnail:
                image_rows = frame_data["thumbnail"]["originalRows"]
                image_cols = frame_data["thumbnail"]["originalColumns"]

            # Featurization
            featurization_start_time = time.time()

            # extract key points
            bodies = frame_data['people']
            rects = []

            person_poses = []

            if self.area_of_interest is not None:
                bodies = list(
                    map(
                        lambda b: get_pts_of_interest_from_person(
                            b, self.area_of_interest), bodies))
            bodies = list(filter(lambda b: check_body_pts(b['body']), bodies))

            for body in bodies:
                body_keypoints = body["body"]
                face_keypoints = body["face"] if "face" in body.keys(
                ) else None

                # prune body keypoints
                body_keypoints = prune_body_pts(body_keypoints)
                body["body"] = body_keypoints
                pose = get_pose_pts(body_keypoints)
                body['inference'] = {'posture': {}, 'face': {}, 'head': {}}
                # prepare inter-frame tracking
                box = get_pose_box(pose)
                rects.append(box.astype("int"))
                person_poses.append(pose)

            # Interframe
            interframe_start_time = time.time()
            tracking_id = None

            objects, poses = self.centroid_tracker.update(rects, person_poses)

            for body in bodies:
                body_keypoints = body["body"]
                pose = get_pose_pts(body_keypoints)
                for (objectID, person_pose) in poses.items():
                    if pose[1][0] == person_pose[1][0] and pose[1][
                            1] == person_pose[1][1]:
                        body['inference']['trackingId'] = objectID + 1
                        if self.video_out is not None or (
                                self.file_params is not None
                                and self.file_params['image']):
                            text = "ID {}".format(objectID)
                            cv2.putText(raw_image, text,
                                        (person_pose[1][0] - 10,
                                         person_pose[1][1] - 10),
                                        cv2.FONT_HERSHEY_SIMPLEX, 1,
                                        (0, 255, 0), 2)
                            cv2.circle(raw_image,
                                       (person_pose[1][0], person_pose[1][1]),
                                       4, (0, 255, 0), -1)
                        break

            interframe_time = time.time() - interframe_start_time

            if self.channel == 'instructor':
                y_min = None
                instructor_body_track = None
                for (objectID, person_pose) in poses.items():
                    if y_min is None and person_pose[1][1] > 0 and person_pose[
                            1][0] > 0:
                        y_min = person_pose[1][1]
                        instructor_body_track = person_pose
                    else:
                        if person_pose[1][1] < y_min and person_pose[1][
                                1] > 0 and person_pose[1][0] > 0:
                            y_min = person_pose[1][1]
                            instructor_body_track = person_pose

                new_bodies = []
                if instructor_body_track is not None:
                    for body in bodies:
                        body_keypoints = body["body"]
                        pose = get_pose_pts(body_keypoints)
                        if pose[1][0] == instructor_body_track[1][0] and pose[
                                1][1] == instructor_body_track[1][1]:
                            new_bodies.append(body)
                            break
                bodies = new_bodies

            for body in bodies:
                body_keypoints = body["body"]
                face_keypoints = body["face"] if "face" in body.keys(
                ) else None
                pose = get_pose_pts(body_keypoints)

                # face orientation
                faceOrientation = None
                faceOrientation = get_facing_direction(pose)

                # Sit stand
                sit_stand, color_stand, pts = predict_sit_stand(body_keypoints)
                if self.video_out is not None or (self.file_params is not None
                                                  and
                                                  self.file_params['image']):
                    cv2.putText(raw_image, sit_stand,
                                (int(pts[1][0]) - 10, int(pts[1][1]) + 30),
                                cv2.FONT_HERSHEY_SIMPLEX, 0.75, color_stand, 2,
                                cv2.LINE_AA)

                # Armpose
                armpose, color_pose, pts = predict_armpose(body_keypoints)
                if self.video_out is not None or (self.file_params is not None
                                                  and
                                                  self.file_params['image']):
                    cv2.putText(raw_image, armpose,
                                (int(pts[1][0]) - 10, int(pts[1][1]) + 10),
                                cv2.FONT_HERSHEY_SIMPLEX, 0.75, color_pose, 2,
                                cv2.LINE_AA)
                    raw_image = render_pose_draw([pose], raw_image, color_pose,
                                                 color_stand)

                # Mouth
                mouth = None
                smile = None
                if face_keypoints is not None:
                    mouth, _, smile, _ = predict_mouth(face_keypoints)

                tvec = None
                yaw = None
                pitch = None
                roll = None
                gaze_vector = None
                face = get_face(pose)

                if (self.process_gaze):
                    tvec = get_3d_head_position(pose, raw_image.shape)
                    # face box
                    if face is not None:
                        face_crop = raw_image[face[0][1]:face[1][1],
                                              face[0][0]:face[1][0]]
                        if face_crop.shape[0] >= 64 and face_crop.shape[
                                1] >= 64:
                            yaw, pitch, roll, gaze_start, gaze_stop = get_head_pose_vector(
                                face_crop, face)
                            yaw = yaw.flatten().tolist()[0]
                            pitch = pitch.flatten().tolist()[0]
                            roll = roll.flatten().tolist()[0]
                            gaze_vector = [gaze_start, gaze_stop]
                            cv2.line(raw_image, gaze_start, gaze_stop,
                                     (255, 255, 255), 2)

                if armpose is not None:
                    body['inference']['posture']['armPose'] = armpose
                if sit_stand is not None:
                    body['inference']['posture']['sitStand'] = sit_stand
                if face is not None:
                    body['inference']['face']['boundingBox'] = face
                if mouth is not None:
                    body['inference']['face']['mouth'] = mouth
                if smile is not None:
                    body['inference']['face']['smile'] = smile
                if yaw is not None:
                    body['inference']['head']['yaw'] = yaw
                if pitch is not None:
                    body['inference']['head']['pitch'] = pitch
                if roll is not None:
                    body['inference']['head']['roll'] = roll
                if faceOrientation is not None:
                    body['inference']['face']['orientation'] = faceOrientation
                if gaze_vector is not None:
                    body['inference']['head']['gazeVector'] = gaze_vector
                if tvec is not None:
                    body['inference']['head']['translationVector'] = tvec

            featurization_time = time.time() - featurization_start_time

            # Acceleration
            prev_objects = self.state['prev_objects']
            previous_time = self.state['prev_time']
            current_time = time.time()

            for body in bodies:
                body_keypoints = body["body"]
                pose = get_pose_pts(body_keypoints)
                for (objectID, person_pose) in poses.items():
                    if prev_objects is not None:
                        for (objectID_2, person_pose2) in prev_objects.items():
                            if objectID == objectID_2:
                                if person_pose2[1][0] != 0 and person_pose2[1][
                                        1] != 0 and person_pose[1][
                                            0] != 0 and person_pose[1][1] != 0:
                                    if pose[1][0] == person_pose[1][0] and pose[
                                            1][1] == person_pose[1][1]:
                                        centroid_delta = []
                                        if previous_time is not None and float(
                                                current_time - previous_time
                                        ) < self.centroid_time_live:
                                            centroid_delta = [
                                                person_pose[1][0] -
                                                person_pose2[1][0],
                                                person_pose[1][1] -
                                                person_pose2[1][1]
                                            ]
                                            if self.video_out is not None or (
                                                    self.file_params
                                                    is not None and
                                                    self.file_params['image']):
                                                cv2.arrowedLine(
                                                    raw_image,
                                                    (person_pose2[1][0],
                                                     person_pose2[1][1]),
                                                    (person_pose[1][0],
                                                     person_pose[1][1]),
                                                    (255, 255, 255), 2,
                                                    cv2.LINE_AA)

                                        arm_delta = None
                                        draw_arm_index = [3, 4, 6, 7]
                                        for i in draw_arm_index:
                                            delta = (0, 0)
                                            if person_pose2[i][
                                                    0] == 0 or person_pose2[i][
                                                        1] == 0 or person_pose[
                                                            i][0] == 0 or person_pose[
                                                                i][1] == 0:
                                                delta = (0, 0)
                                            elif previous_time is not None and float(
                                                    current_time -
                                                    previous_time
                                            ) < self.centroid_time_live:
                                                delta = (person_pose[i][0] -
                                                         person_pose2[i][0],
                                                         person_pose[i][1] -
                                                         person_pose2[i][1])
                                                if self.video_out is not None or (
                                                        self.file_params
                                                        is not None and self.
                                                        file_params['image']):
                                                    cv2.arrowedLine(
                                                        raw_image,
                                                        (person_pose2[i][0],
                                                         person_pose2[i][1]),
                                                        (person_pose[i][0],
                                                         person_pose[i][1]),
                                                        (255, 255, 0), 2,
                                                        cv2.LINE_AA)
                                            if arm_delta is None:
                                                arm_delta = [delta]
                                            else:
                                                arm_delta.append(delta)

                                        body['inference']['posture'][
                                            'centroidDelta'] = centroid_delta
                                        body['inference']['posture'][
                                            'armDelta'] = arm_delta

            if previous_time is None or float(
                    current_time -
                    previous_time) > self.centroid_initialize_time:
                self.state['prev_time'] = current_time
                self.state['prev_objects'] = poses.copy()

            frame_data['channel'] = self.channel
            frame_data['people'] = bodies

            if self.profile:
                print('json,%f' % json_time)
                print('featurization,%f' % featurization_time)
                print('thumbnail,%f' % thumbnail_time)
                print('interframe,%f' % interframe_time)

        except Exception as e:
            traceback.print_exc(file=sys.stdout)

        return raw_image, frame_data
예제 #59
0
    def encrypt_stream(
            encryption_material: SnowflakeFileEncryptionMaterial,
            src: IO[bytes],
            out: IO[bytes],
            chunk_size: int = 64 * kilobyte,  # block_size * 4 * 1024,
    ) -> EncryptionMetadata:
        """Reads content from src and write the encrypted content into out.

        This function is sensitive to current position of src and out.
        It does not seek to position 0 in neither stream objects before or after the encryption.

        Args:
            encryption_material: The encryption material for file.
            src: The input stream.
            out: The output stream.
            chunk_size: The size of read chunks (Default value = block_size * 4 * 1024

        Returns:
            The encryption metadata.
        """
        logger = getLogger(__name__)
        use_openssl_only = os.getenv("SF_USE_OPENSSL_ONLY", "False") == "True"
        decoded_key = base64.standard_b64decode(
            encryption_material.query_stage_master_key)
        key_size = len(decoded_key)
        logger.debug("key_size = %s", key_size)

        # Generate key for data encryption
        iv_data = SnowflakeEncryptionUtil.get_secure_random(block_size)
        file_key = SnowflakeEncryptionUtil.get_secure_random(key_size)
        if not use_openssl_only:
            data_cipher = AES.new(key=file_key, mode=AES.MODE_CBC, IV=iv_data)
        else:
            backend = default_backend()
            cipher = Cipher(algorithms.AES(file_key),
                            modes.CBC(iv_data),
                            backend=backend)
            encryptor = cipher.encryptor()

        padded = False
        while True:
            chunk = src.read(chunk_size)
            if len(chunk) == 0:
                break
            elif len(chunk) % block_size != 0:
                chunk = PKCS5_PAD(chunk, block_size)
                padded = True
            if not use_openssl_only:
                out.write(data_cipher.encrypt(chunk))
            else:
                out.write(encryptor.update(chunk))
        if not padded:
            if not use_openssl_only:
                out.write(
                    data_cipher.encrypt(block_size *
                                        chr(block_size).encode(UTF8)))
            else:
                out.write(
                    encryptor.update(block_size *
                                     chr(block_size).encode(UTF8)))
        if use_openssl_only:
            out.write(encryptor.finalize())

        # encrypt key with QRMK
        if not use_openssl_only:
            key_cipher = AES.new(key=decoded_key, mode=AES.MODE_ECB)
            enc_kek = key_cipher.encrypt(PKCS5_PAD(file_key, block_size))
        else:
            cipher = Cipher(algorithms.AES(decoded_key),
                            modes.ECB(),
                            backend=backend)
            encryptor = cipher.encryptor()
            enc_kek = (encryptor.update(PKCS5_PAD(file_key, block_size)) +
                       encryptor.finalize())

        mat_desc = MaterialDescriptor(
            smk_id=encryption_material.smk_id,
            query_id=encryption_material.query_id,
            key_size=key_size * 8,
        )
        metadata = EncryptionMetadata(
            key=base64.b64encode(enc_kek).decode("utf-8"),
            iv=base64.b64encode(iv_data).decode("utf-8"),
            matdesc=matdesc_to_unicode(mat_desc),
        )
        return metadata
예제 #60
0
 def from_base64(cls, s: str) -> raw:
     """
     Convert Base64 UTF-8 string representation of a raw value.
     """
     return bytes.__new__(cls, base64.standard_b64decode(s))