Esempio n. 1
0
    def setUp(self):
        """
        Switch to test config.
        Create initial files set in the Upload Dir.
        Remember initial blacklist content.
        """
        self.app = storj.app
        self.app.config['TESTING'] = True

        self.blocked_data = b'blocked_data'
        self.blocked_hash = sha256(self.blocked_data).hexdigest()
        with open(self.app.config['BLACKLIST_FILE'], 'r+') as fp:
            self.initial_blacklist = fp.read()
            fp.writelines((self.blocked_hash + '\n',))

        self.files_id = files.insert().values(
            hash=sha256(b'_').hexdigest(), role='000', size=1,
            owner=test_owner_address
        ).execute().inserted_primary_key

        self.files_id.extend(
            files.insert().values(
                hash=sha256(b'__').hexdigest(), role='000', size=2,
                owner=test_owner_address
            ).execute().inserted_primary_key
        )
Esempio n. 2
0
def upload(file, data_hash, role, sender, signature):
    """
    Check if data_hash is valid SHA-256 hash matched with uploading file.
    Check file size.
    Save uploaded file to the Upload Dir and insert a record in the 'files'
    table.

    :param file: file-like object with binary data
    :param data_hash: SHA-256 hash for data
    :param role: file role
    :param sender: file sender's BitCoin address
    :param signature: data signature
    """
    node = app.config['NODE']
    checker = Checker(data_hash, sender, signature)

    checks_result = checker.check_all('double_uploading')
    if checks_result:
        return {'file_role': checker.file.role}

    checks_result = checker.check_all('signature', 'hash', 'blacklist')
    if checks_result:
        return checks_result

    file_data = file.read()
    file_size = len(file_data)

    try:
        os.makedirs(app.config['UPLOAD_FOLDER'])
    except OSError:
        pass

    if file_size > app.config['MAX_FILE_SIZE']:
        return ERR_TRANSFER['HUGE_FILE']

    if file_size > node.capacity:
        return ERR_TRANSFER['FULL_DISK']

    if node.limits['incoming'] is not None and (
                file_size > node.limits['incoming'] - node.current['incoming']
    ):
        return ERR_TRANSFER['LIMIT_REACHED']

    if data_hash != sha256(file_data).hexdigest():
        return ERR_TRANSFER['MISMATCHED_HASH']

    with open(os.path.join(app.config['UPLOAD_FOLDER'], data_hash),
              'wb') as file_to_save:
        file_to_save.write(file_data)

    files.insert().values(
        hash=data_hash,
        role=role,
        size=len(file_data),
        owner=sender
    ).execute()
Esempio n. 3
0
    def test_success_get_info_with_existing_files_and_hide_blocked(self):
        """
        Successful getting files info with existing files
        and hide blocked ones.
        """
        self.files_id.extend(
            files.insert().values(
                hash=self.blocked_hash, role='000',
                size=len(self.blocked_data), owner=test_owner_address
            ).execute().inserted_primary_key
        )

        with self.app.test_client() as c:
            response = c.get(path=self.url)

        self.assertEqual(200, response.status_code,
                         "'OK' status code is expected.")
        self.assertEqual('application/json', response.content_type,
                         "Has to be a JSON-response.")

        data = json.loads(response.data.decode())

        self.assertIsInstance(data, list, "Has to be an array.")

        self.assertSetEqual(
            set(_['hash'] for _ in files.select(
                files.c.hash != self.blocked_hash
            ).execute()),
            set(data),
            "Has to contain all files hashes without blacklisted ones."
        )
Esempio n. 4
0
    def setUp(self):
        """
        Switch to test config.
        Create initial files set in the Upload Dir.
        Create initial records in the 'files' table.
        Remember challenge seed and response.
        Remember initial blacklist content.
        """
        self.app = storj.app
        self.app.config['TESTING'] = True

        self.file_data = b'existing file data'
        self.data_hash = sha256(self.file_data).hexdigest()
        valid_signature = test_btctx_api.sign_unicode(test_owner_wif,
                                                      self.data_hash)

        self.blocked_data = b'blocked_data'
        self.blocked_hash = sha256(self.blocked_data).hexdigest()
        with open(self.app.config['BLACKLIST_FILE'], 'r+') as fp:
            self.initial_blacklist = fp.read()
            fp.writelines((self.blocked_hash + '\n',))

        self.file_saving_path = os.path.join(
            self.app.config['UPLOAD_FOLDER'], self.data_hash
        )

        with open(self.file_saving_path, 'wb') as stored_file:
            stored_file.write(self.file_data)

        self.owner = test_owner_address

        self.files_id = files.insert().values(
            hash=self.data_hash, role='000', size=len(self.file_data),
            owner=self.owner
        ).execute().inserted_primary_key

        audit.delete().execute()

        self.challenge_seed = sha256(b'seed').hexdigest()
        self.challenge_response = sha256(
            self.file_data + self.challenge_seed.encode()
        ).hexdigest()

        self.send_data = {
            'data_hash': self.data_hash,
            'challenge_seed': self.challenge_seed
        }

        self.headers = {
            'sender_address': self.owner,
            'signature': valid_signature
        }

        self.other = test_other_address
        self.other_signature = test_btctx_api.sign_unicode(test_other_wfi,
                                                           self.data_hash)

        self.patcher = patch('metacore.processor.BTCTX_API', test_btctx_api)
        self.patcher.start()
Esempio n. 5
0
    def setUp(self):
        """
        Switch to test config.
        Create initial files set in the Upload Dir.
        Create initial records in the 'files' table.
        """
        self.app = storj.app
        self.app.config['TESTING'] = True

        self.file_data = b'existing file data'

        temp_hash = sha256(self.file_data).hexdigest()

        file_path = os.path.join(
            self.app.config['UPLOAD_FOLDER'], temp_hash
        )

        with open(file_path, 'wb') as fp:
            fp.write(self.file_data)

        self.key = binascii.hexlify(
                convergence.encrypt_file_inline(file_path, None))

        with open(file_path, 'rb') as fp:
            self.encrypted_data = fp.read()

        self.data_hash = sha256(self.encrypted_data).hexdigest()
        valid_signature = test_btctx_api.sign_unicode(test_owner_wif,
                                                      self.data_hash)
        self.file_saving_path = os.path.join(self.app.config['UPLOAD_FOLDER'],
                                             self.data_hash)
        os.rename(file_path, self.file_saving_path)

        self.files_id = files.insert().values(
            hash=self.data_hash, role='001', size=len(self.encrypted_data),
            owner=test_owner_address
        ).execute().inserted_primary_key

        self.headers = {
            'sender_address': test_owner_address,
            'signature': valid_signature
        }

        self.query_string = {
            'decryption_key': self.key,
            'file_alias': 'file.txt'
        }

        self.patcher = patch('metacore.processor.BTCTX_API', test_btctx_api)
        self.patcher.start()
Esempio n. 6
0
    def test_non_authenticated_access(self):
        """
        Testing the non-authenticated public access to files with "001" and
        "101" values of the role.
        """
        self.headers = {}
        cached_data_from_setup = self.data_hash
        public_shared_data_tuple = (b'001',
            b'101')
        for public_shared_data in public_shared_data_tuple:
            public_data_hash = sha256(public_shared_data).hexdigest()
            self.data_hash= public_data_hash

            shared_file_path = os.path.join(
                self.app.config['UPLOAD_FOLDER'], public_data_hash
            )
            with open(shared_file_path, 'wb') as stored_file:
                stored_file.write(public_shared_data)

            self.files_id += files.insert().values(
                hash=public_data_hash,
                role=public_shared_data.decode(),
                size=len(public_shared_data),
                owner=test_owner_address
            ).execute().inserted_primary_key
            response = self.make_request()
            self.assertEqual(response.data, public_shared_data,
                             "Stored file content is expected.")
            try:
                pass
                os.unlink(shared_file_path)
            except OSError:
                pass
        self.data_hash = cached_data_from_setup
        response = self.make_request()
        self.assertDictEqual({'error_code': ERR_TRANSFER['INVALID_SIGNATURE']},
                             json.loads(response.data.decode()),
                             "Unexpected response data.")