def _op_create(self, page_size=4096):
dpb = bs([1])
s = self.str_to_bytes(self.charset)
dpb += bs([isc_dpb_set_db_charset, len(s)]) + s
dpb += bs([isc_dpb_lc_ctype, len(s)]) + s
s = self.str_to_bytes(self.user)
dpb += bs([isc_dpb_user_name, len(s)]) + s
if self.accept_version < PROTOCOL_VERSION13:
enc_pass = get_crypt(self.password)
if self.accept_version == PROTOCOL_VERSION10 or not enc_pass:
s = self.str_to_bytes(self.password)
dpb += bs([isc_dpb_password, len(s)]) + s
else:
enc_pass = self.str_to_bytes(enc_pass)
dpb += bs([isc_dpb_password_enc, len(enc_pass)]) + enc_pass
if self.role:
s = self.str_to_bytes(self.role)
dpb += bs([isc_dpb_sql_role_name, len(s)]) + s
if self.auth_data:
s = bytes_to_hex(self.auth_data)
dpb += bs([isc_dpb_specific_auth_data, len(s)]) + s
if self.timezone:
s = self.str_to_bytes(self.timezone)
dpb += bs([isc_dpb_session_time_zone, len(s)]) + s
dpb += bs([isc_dpb_sql_dialect, 4]) + int_to_bytes(3, 4)
dpb += bs([isc_dpb_force_write, 4]) + int_to_bytes(1, 4)
dpb += bs([isc_dpb_overwrite, 4]) + int_to_bytes(1, 4)
dpb += bs([isc_dpb_page_size, 4]) + int_to_bytes(page_size, 4)
p = xdrlib.Packer()
p.pack_int(self.op_create)
p.pack_int(0) # Database Object ID
p.pack_bytes(self.str_to_bytes(self.filename))
p.pack_bytes(dpb)
self.sock.send(p.get_buffer())
def _op_attach(self):
dpb = bs([isc_dpb_version1])
s = self.str_to_bytes(self.charset)
dpb += bs([isc_dpb_lc_ctype, len(s)]) + s
s = self.str_to_bytes(self.user)
dpb += bs([isc_dpb_user_name, len(s)]) + s
if self.accept_version < PROTOCOL_VERSION13:
enc_pass = get_crypt(self.password)
if self.accept_version == PROTOCOL_VERSION10 or not enc_pass:
s = self.str_to_bytes(self.password)
dpb += bs([isc_dpb_password, len(s)]) + s
else:
enc_pass = self.str_to_bytes(enc_pass)
dpb += bs([isc_dpb_password_enc, len(enc_pass)]) + enc_pass
if self.role:
s = self.str_to_bytes(self.role)
dpb += bs([isc_dpb_sql_role_name, len(s)]) + s
dpb += bs([isc_dpb_process_id, 4]) + int_to_bytes(os.getpid(), 4)
s = self.str_to_bytes(sys.argv[0])
dpb += bs([isc_dpb_process_name, len(s)]) + s
if self.auth_data:
s = bytes_to_hex(self.auth_data)
dpb += bs([isc_dpb_specific_auth_data, len(s)]) + s
if self.timezone:
s = self.str_to_bytes(self.timezone)
dpb += bs([isc_dpb_session_time_zone, len(s)]) + s
p = xdrlib.Packer()
p.pack_int(self.op_attach)
p.pack_int(0) # Database Object ID
p.pack_bytes(self.str_to_bytes(self.filename))
p.pack_bytes(dpb)
self.sock.send(p.get_buffer())
def _op_detach(self):
if self.db_handle is None:
raise OperationalError('_op_detach() Invalid db handle')
p = xdrlib.Packer()
p.pack_int(self.op_detach)
p.pack_int(self.db_handle)
self.sock.send(p.get_buffer())
def _op_get_segment(self, blob_handle):
p = xdrlib.Packer()
p.pack_int(self.op_get_segment)
p.pack_int(blob_handle)
p.pack_int(self.buffer_length)
p.pack_int(0)
self.sock.send(p.get_buffer())
def _op_transaction(self, tpb):
if self.db_handle is None:
raise OperationalError('_op_transaction() Invalid db handle')
p = xdrlib.Packer()
p.pack_int(self.op_transaction)
p.pack_int(self.db_handle)
p.pack_bytes(tpb)
self.sock.send(p.get_buffer())
def _op_info_transaction(self, trans_handle, b):
p = xdrlib.Packer()
p.pack_int(self.op_info_transaction)
p.pack_int(trans_handle)
p.pack_int(0)
p.pack_bytes(b)
p.pack_int(self.buffer_length)
self.sock.send(p.get_buffer())
def _op_cancel_events(self, event_id):
if self.db_handle is None:
raise OperationalError('_op_cancel_events() Invalid db handle')
p = xdrlib.Packer()
p.pack_int(self.op_cancel_events)
p.pack_int(self.db_handle)
p.pack_int(event_id)
self.sock.send(p.get_buffer())
def _op_info_sql(self, stmt_handle, vars):
p = xdrlib.Packer()
p.pack_int(self.op_info_sql)
p.pack_int(stmt_handle)
p.pack_int(0)
p.pack_bytes(vars)
p.pack_int(self.buffer_length)
self.sock.send(p.get_buffer())
def _op_fetch(self, stmt_handle, blr):
p = xdrlib.Packer()
p.pack_int(self.op_fetch)
p.pack_int(stmt_handle)
p.pack_bytes(blr)
p.pack_int(0)
p.pack_int(400)
self.sock.send(p.get_buffer())
def _op_create_blob2(self, trans_handle):
p = xdrlib.Packer()
p.pack_int(self.op_create_blob2)
p.pack_int(0)
p.pack_int(trans_handle)
p.pack_int(0)
p.pack_int(0)
self.sock.send(p.get_buffer())
def _op_cont_auth(self, auth_data, auth_plugin_name, auth_plugin_list,
keys):
p = xdrlib.Packer()
p.pack_int(self.op_cont_auth)
p.pack_bytes(bytes_to_hex(auth_data))
p.pack_bytes(auth_plugin_name)
p.pack_bytes(auth_plugin_list)
p.pack_bytes(keys)
self.sock.send(p.get_buffer())
def _op_connect_request(self):
if self.db_handle is None:
raise OperationalError('_op_connect_request() Invalid db handle')
p = xdrlib.Packer()
p.pack_int(self.op_connect_request)
p.pack_int(1) # async
p.pack_int(self.db_handle)
p.pack_int(0)
self.sock.send(p.get_buffer())
def _op_put_segment(self, blob_handle, seg_data):
ln = len(seg_data)
p = xdrlib.Packer()
p.pack_int(self.op_put_segment)
p.pack_int(blob_handle)
p.pack_int(ln)
p.pack_int(ln)
pad_length = (4 - ln) & 3
self.sock.send(p.get_buffer() + seg_data + bs([0]) * pad_length)
def _op_service_start(self, param):
if self.db_handle is None:
raise OperationalError('_op_service_start() Invalid db handle')
p = xdrlib.Packer()
p.pack_int(self.op_service_start)
p.pack_int(self.db_handle)
p.pack_int(0)
p.pack_bytes(param)
self.sock.send(p.get_buffer())
def _op_info_database(self, b):
if self.db_handle is None:
raise OperationalError('_op_info_database() Invalid db handle')
p = xdrlib.Packer()
p.pack_int(self.op_info_database)
p.pack_int(self.db_handle)
p.pack_int(0)
p.pack_bytes(b)
p.pack_int(self.buffer_length)
self.sock.send(p.get_buffer())
def _op_batch_segments(self, blob_handle, seg_data):
ln = len(seg_data)
p = xdrlib.Packer()
p.pack_int(self.op_batch_segments)
p.pack_int(blob_handle)
p.pack_int(ln + 2)
p.pack_int(ln + 2)
pad_length = ((4 - (ln + 2)) & 3)
self.sock.send(p.get_buffer() + int_to_bytes(ln, 2) + seg_data +
bs([0]) * pad_length)
def _op_service_info(self, param, item, buffer_length=512):
if self.db_handle is None:
raise OperationalError('_op_service_info() Invalid db handle')
p = xdrlib.Packer()
p.pack_int(self.op_service_info)
p.pack_int(self.db_handle)
p.pack_int(0)
p.pack_bytes(param)
p.pack_bytes(item)
p.pack_int(buffer_length)
self.sock.send(p.get_buffer())
def _op_execute2(self, stmt_handle, trans_handle, params, output_blr):
p = xdrlib.Packer()
p.pack_int(self.op_execute2)
p.pack_int(stmt_handle)
p.pack_int(trans_handle)
if len(params) == 0:
values = b''
p.pack_bytes(bs([]))
p.pack_int(0)
p.pack_int(0)
else:
(blr, values) = self.params_to_blr(trans_handle, params)
p.pack_bytes(blr)
p.pack_int(0)
p.pack_int(1)
q = xdrlib.Packer()
q.pack_bytes(output_blr)
q.pack_int(0)
self.sock.send(p.get_buffer() + values + q.get_buffer())
def _op_exec_immediate(self, trans_handle, query):
if self.db_handle is None:
raise OperationalError('_op_exec_immediate() Invalid db handle')
desc_items = bs([])
p = xdrlib.Packer()
p.pack_int(self.op_exec_immediate)
p.pack_int(trans_handle)
p.pack_int(self.db_handle)
p.pack_int(3) # dialect = 3
p.pack_bytes(self.str_to_bytes(query))
p.pack_bytes(desc_items)
p.pack_int(self.buffer_length)
self.sock.send(p.get_buffer())
def _op_que_events(self, event_names, event_id):
if self.db_handle is None:
raise OperationalError('_op_que_events() Invalid db handle')
params = bs([1])
for name, n in event_names.items():
params += bs([len(name)])
params += self.str_to_bytes(name)
params += int_to_bytes(n, 4)
p = xdrlib.Packer()
p.pack_int(self.op_que_events)
p.pack_int(self.db_handle)
p.pack_bytes(params)
p.pack_int(0) # ast
p.pack_int(0) # args
p.pack_int(event_id)
self.sock.send(p.get_buffer())
def _op_execute(self, stmt_handle, trans_handle, params):
p = xdrlib.Packer()
p.pack_int(self.op_execute)
p.pack_int(stmt_handle)
p.pack_int(trans_handle)
if len(params) == 0:
p.pack_bytes(bs([]))
p.pack_int(0)
p.pack_int(0)
self.sock.send(p.get_buffer())
else:
(blr, values) = self.params_to_blr(trans_handle, params)
p.pack_bytes(blr)
p.pack_int(0)
p.pack_int(1)
self.sock.send(p.get_buffer() + values)
def _op_prepare_statement(self,
stmt_handle,
trans_handle,
query,
option_items=None):
if option_items is None:
option_items = bs([])
desc_items = option_items + bs([isc_info_sql_stmt_type
]) + INFO_SQL_SELECT_DESCRIBE_VARS
p = xdrlib.Packer()
p.pack_int(self.op_prepare_statement)
p.pack_int(trans_handle)
p.pack_int(stmt_handle)
p.pack_int(3) # dialect = 3
p.pack_bytes(self.str_to_bytes(query))
p.pack_bytes(desc_items)
p.pack_int(self.buffer_length)
self.sock.send(p.get_buffer())
def _op_connect(self, auth_plugin_name, wire_crypt):
protocols = [
# PROTOCOL_VERSION, Arch type (Generic=1), min, max, weight
'0000000a00000001000000000000000500000002', # 10, 1, 0, 5, 2
'ffff800b00000001000000000000000500000004', # 11, 1, 0, 5, 4
'ffff800c00000001000000000000000500000006', # 12, 1, 0, 5, 6
'ffff800d00000001000000000000000500000008', # 13, 1, 0, 5, 8
]
p = xdrlib.Packer()
p.pack_int(self.op_connect)
p.pack_int(self.op_attach)
p.pack_int(3) # CONNECT_VERSION
p.pack_int(1) # arch_generic
p.pack_bytes(self.str_to_bytes(self.filename if self.filename else ''))
p.pack_int(len(protocols))
p.pack_bytes(self.uid(auth_plugin_name, wire_crypt))
self.sock.send(p.get_buffer() + hex_to_bytes(''.join(protocols)))
def _op_service_attach(self):
spb = bs([2, 2])
s = self.str_to_bytes(self.user)
spb += bs([isc_spb_user_name, len(s)]) + s
if self.accept_version < PROTOCOL_VERSION13:
enc_pass = get_crypt(self.password)
if self.accept_version == PROTOCOL_VERSION10 or not enc_pass:
s = self.str_to_bytes(self.password)
spb += bs([isc_dpb_password, len(s)]) + s
else:
enc_pass = self.str_to_bytes(enc_pass)
spb += bs([isc_dpb_password_enc, len(enc_pass)]) + enc_pass
if self.auth_data:
s = self.str_to_bytes(bytes_to_hex(self.auth_data))
spb += bs([isc_dpb_specific_auth_data, len(s)]) + s
spb += bs(
[isc_spb_dummy_packet_interval, 0x04, 0x78, 0x0a, 0x00, 0x00])
p = xdrlib.Packer()
p.pack_int(self.op_service_attach)
p.pack_int(0)
p.pack_bytes(b'service_mgr')
p.pack_bytes(spb)
self.sock.send(p.get_buffer())
def _op_open_blob(self, blob_id, trans_handle):
p = xdrlib.Packer()
p.pack_int(self.op_open_blob)
p.pack_int(trans_handle)
self.sock.send(p.get_buffer() + blob_id)
def _op_close_blob(self, blob_handle):
p = xdrlib.Packer()
p.pack_int(self.op_close_blob)
p.pack_int(blob_handle)
self.sock.send(p.get_buffer())
def _op_free_statement(self, stmt_handle, mode):
p = xdrlib.Packer()
p.pack_int(self.op_free_statement)
p.pack_int(stmt_handle)
p.pack_int(mode)
self.sock.send(p.get_buffer())
def _op_rollback_retaining(self, trans_handle):
p = xdrlib.Packer()
p.pack_int(self.op_rollback_retaining)
p.pack_int(trans_handle)
self.sock.send(p.get_buffer())
def _op_commit(self, trans_handle):
p = xdrlib.Packer()
p.pack_int(self.op_commit)
p.pack_int(trans_handle)
self.sock.send(p.get_buffer())
def _parse_connect_response(self):
# want and treat op_accept or op_cond_accept or op_accept_data
b = self.recv_channel(4)
while bytes_to_bint(b) == self.op_dummy:
b = self.recv_channel(4)
if bytes_to_bint(b) == self.op_reject:
raise OperationalError('Connection is rejected')
op_code = bytes_to_bint(b)
if op_code == self.op_response:
return self._parse_op_response() # error occured
b = self.recv_channel(12)
self.accept_version = byte_to_int(b[3])
self.accept_architecture = bytes_to_bint(b[4:8])
self.accept_type = bytes_to_bint(b[8:])
self.lazy_response_count = 0
if op_code == self.op_cond_accept or op_code == self.op_accept_data:
ln = bytes_to_bint(self.recv_channel(4))
data = self.recv_channel(ln, word_alignment=True)
ln = bytes_to_bint(self.recv_channel(4))
self.accept_plugin_name = self.recv_channel(ln,
word_alignment=True)
is_authenticated = bytes_to_bint(self.recv_channel(4))
ln = bytes_to_bint(self.recv_channel(4))
self.recv_channel(ln, word_alignment=True) # keys
if is_authenticated == 0:
if self.accept_plugin_name in (b'Srp256', b'Srp'):
hash_algo = {
b'Srp256': hashlib.sha256,
b'Srp': hashlib.sha1,
}[self.accept_plugin_name]
user = self.user
if len(user) > 2 and user[0] == user[-1] == '"':
user = user[1:-1]
user = user.replace('""', '"')
else:
user = user.upper()
if len(data) == 0:
# send op_cont_auth
self._op_cont_auth(
srp.long2bytes(self.client_public_key),
self.accept_plugin_name, self.plugin_list, b'')
# parse op_cont_auth
b = self.recv_channel(4)
assert bytes_to_bint(b) == self.op_cont_auth
ln = bytes_to_bint(self.recv_channel(4))
data = self.recv_channel(ln, word_alignment=True)
ln = bytes_to_bint(self.recv_channel(4))
plugin_name = self.recv_channel(ln,
word_alignment=True)
ln = bytes_to_bint(self.recv_channel(4))
plugin_list = self.recv_channel(ln,
word_alignment=True)
ln = bytes_to_bint(self.recv_channel(4))
keys = self.recv_channel(ln, word_alignment=True)
ln = bytes_to_int(data[:2])
server_salt = data[2:ln + 2]
server_public_key = srp.bytes2long(
hex_to_bytes(data[4 + ln:]))
auth_data, session_key = srp.client_proof(
self.str_to_bytes(user),
self.str_to_bytes(self.password), server_salt,
self.client_public_key, server_public_key,
self.client_private_key, hash_algo)
elif self.accept_plugin_name == b'Legacy_Auth':
auth_data = self.str_to_bytes(get_crypt(self.password))
session_key = b''
else:
raise OperationalError('Unknown auth plugin %s' %
(self.accept_plugin_name))
else:
auth_data = b''
session_key = b''
if op_code == self.op_cond_accept:
self._op_cont_auth(auth_data, self.accept_plugin_name,
self.plugin_list, b'')
(h, oid, buf) = self._op_response()
if self.wire_crypt and session_key:
# op_crypt: plugin[Arc4] key[Symmetric]
p = xdrlib.Packer()
p.pack_int(self.op_crypt)
p.pack_bytes(b'Arc4')
p.pack_bytes(b'Symmetric')
self.sock.send(p.get_buffer())
self.sock.set_translator(ARC4.new(session_key),
ARC4.new(session_key))
(h, oid, buf) = self._op_response()
else: # use later _op_attach() and _op_create()
self.auth_data = auth_data
else:
assert op_code == self.op_accept
