def test_acquire_creds_impersonate_name(self):
target_name = gb.importName(TARGET_SERVICE_NAME)
client_ctx_resp = gb.initSecContext(target_name)
client_token = client_ctx_resp[3]
del client_ctx_resp # free all the things (except the token)!
server_name = gb.importName(SERVICE_PRINCIPAL,
gb.NameType.principal)
server_creds = gb.acquireCred(server_name, cred_usage='both')[0]
server_ctx_resp = gb.acceptSecContext(client_token,
acceptor_cred=server_creds)
imp_resp = gb.acquireCredImpersonateName(server_creds,
server_ctx_resp[1])
imp_resp.shouldnt_be_none()
imp_creds, actual_mechs, output_ttl = imp_resp
imp_creds.shouldnt_be_none()
imp_creds.should_be_a(gb.Creds)
actual_mechs.shouldnt_be_empty()
actual_mechs.should_include(gb.MechType.kerberos)
output_ttl.should_be_a(int)
def test_compare_name(self):
service_name1 = gb.importName(TARGET_SERVICE_NAME)
service_name2 = gb.importName(TARGET_SERVICE_NAME)
init_name = gb.importName(INITIATOR_PRINCIPAL, gb.NameType.principal)
gb.compareName(service_name1, service_name2).should_be_true()
gb.compareName(service_name2, service_name1).should_be_true()
gb.compareName(service_name1, init_name).should_be_false()
gb.releaseName(service_name1)
gb.releaseName(service_name2)
gb.releaseName(init_name)
def test_compare_name(self):
service_name1 = gb.importName(TARGET_SERVICE_NAME)
service_name2 = gb.importName(TARGET_SERVICE_NAME)
init_name = gb.importName(INITIATOR_PRINCIPAL, gb.NameType.principal)
gb.compareName(service_name1, service_name2).should_be_true()
gb.compareName(service_name2, service_name1).should_be_true()
gb.compareName(service_name1, init_name).should_be_false()
gb.releaseName(service_name1)
gb.releaseName(service_name2)
gb.releaseName(init_name)
def setUp(self):
self.target_name = gb.importName(TARGET_SERVICE_NAME)
ctx_resp = gb.initSecContext(self.target_name)
self.client_token = ctx_resp[3]
self.client_ctx = ctx_resp[0]
self.client_ctx.shouldnt_be_none()
self.server_name = gb.importName(SERVICE_PRINCIPAL,
gb.NameType.principal)
self.server_creds = gb.acquireCred(self.server_name)[0]
self.server_ctx = None
def setUp(self):
self.target_name = gb.importName(TARGET_SERVICE_NAME)
ctx_resp = gb.initSecContext(self.target_name)
self.client_token = ctx_resp[3]
self.client_ctx = ctx_resp[0]
self.client_ctx.shouldnt_be_none()
str_server_name = (TARGET_SERVICE_NAME + b'/' +
socket.getfqdn().encode('utf-8'))
self.server_name = gb.importName(str_server_name,
gb.NameType.principal)
self.server_creds = gb.acquireCred(self.server_name)[0]
self.server_ctx = None
def setUp(self):
self.target_name = gb.importName(TARGET_SERVICE_NAME)
ctx_resp = gb.initSecContext(self.target_name)
self.client_token = ctx_resp[3]
self.client_ctx = ctx_resp[0]
self.client_ctx.shouldnt_be_none()
str_server_name = (TARGET_SERVICE_NAME + b'/' +
socket.getfqdn().encode('utf-8'))
self.server_name = gb.importName(str_server_name,
gb.NameType.principal)
self.server_creds = gb.acquireCred(self.server_name)[0]
self.server_ctx = None
def __init__(self):
self.ctx = None
str_server_name = (TARGET_SERVICE_NAME.encode('utf-8') + b'/' +
socket.getfqdn().encode('utf-8'))
self.server_name = gb.importName(str_server_name,
gb.NameType.principal)
self.server_creds = gb.acquireCred(self.server_name)[0]
def test_import_name(self):
imported_name = gb.importName(TARGET_SERVICE_NAME)
imported_name.shouldnt_be_none()
imported_name.should_be_a(gb.Name)
gb.releaseName(imported_name)
def test_import_name(self):
imported_name = gb.importName(TARGET_SERVICE_NAME)
imported_name.shouldnt_be_none()
imported_name.should_be_a(gb.Name)
gb.releaseName(imported_name)
def __init__(self):
self.ctx = None
str_server_name = (TARGET_SERVICE_NAME.encode('utf-8') + b'/' +
socket.getfqdn().encode('utf-8'))
self.server_name = gb.importName(str_server_name,
gb.NameType.principal)
self.server_creds = gb.acquireCred(self.server_name)[0]
def test_inquire_context(self):
target_name = gb.importName(TARGET_SERVICE_NAME)
ctx_resp = gb.initSecContext(target_name)
client_token1 = ctx_resp[3]
client_ctx = ctx_resp[0]
str_server_name = (TARGET_SERVICE_NAME + b'/' +
socket.getfqdn().encode('utf-8'))
server_name = gb.importName(str_server_name,
gb.NameType.principal)
server_creds = gb.acquireCred(server_name)[0]
server_resp = gb.acceptSecContext(client_token1,
acceptor_cred=server_creds)
server_tok = server_resp[3]
client_resp2 = gb.initSecContext(target_name,
context=client_ctx,
input_token=server_tok)
ctx = client_resp2[0]
inq_resp = gb.inquireContext(ctx)
inq_resp.shouldnt_be_none()
(src_name, target_name, ttl, mech_type,
flags, local_est, is_open) = inq_resp
src_name.shouldnt_be_none()
src_name.should_be_a(gb.Name)
target_name.shouldnt_be_none()
target_name.should_be_a(gb.Name)
ttl.should_be_an_integer()
mech_type.shouldnt_be_none()
mech_type.should_be(gb.MechType.kerberos)
flags.shouldnt_be_none()
flags.should_be_a(list)
flags.shouldnt_be_empty()
local_est.should_be_a(bool)
local_est.should_be_true()
is_open.should_be_a(bool)
is_open.should_be_true()
def __new__(cls, name=None, name_type=gss.NameType.hostbased_service,
base_name=None):
if base_name is None:
base_res = gss.importName(name.encode('utf-8'), name_type)
else:
base_res = base_name
return super(GSSName, cls).__new__(cls, base_res)
def test_inquire_context(self):
target_name = gb.importName(TARGET_SERVICE_NAME)
ctx_resp = gb.initSecContext(target_name)
client_token1 = ctx_resp[3]
client_ctx = ctx_resp[0]
str_server_name = (TARGET_SERVICE_NAME + b'/' +
socket.getfqdn().encode('utf-8'))
server_name = gb.importName(str_server_name, gb.NameType.principal)
server_creds = gb.acquireCred(server_name)[0]
server_resp = gb.acceptSecContext(client_token1,
acceptor_cred=server_creds)
server_tok = server_resp[3]
client_resp2 = gb.initSecContext(target_name,
context=client_ctx,
input_token=server_tok)
ctx = client_resp2[0]
inq_resp = gb.inquireContext(ctx)
inq_resp.shouldnt_be_none()
(src_name, target_name, ttl, mech_type, flags, local_est,
is_open) = inq_resp
src_name.shouldnt_be_none()
src_name.should_be_a(gb.Name)
target_name.shouldnt_be_none()
target_name.should_be_a(gb.Name)
ttl.should_be_an_integer()
mech_type.shouldnt_be_none()
mech_type.should_be(gb.MechType.kerberos)
flags.shouldnt_be_none()
flags.should_be_a(list)
flags.shouldnt_be_empty()
local_est.should_be_a(bool)
local_est.should_be_true()
is_open.should_be_a(bool)
is_open.should_be_true()
def setUp(self):
self.target_name = gb.importName(TARGET_SERVICE_NAME)
ctx_resp = gb.initSecContext(self.target_name)
self.client_token1 = ctx_resp[3]
self.client_ctx = ctx_resp[0]
self.server_name = gb.importName(SERVICE_PRINCIPAL,
gb.NameType.principal)
self.server_creds = gb.acquireCred(self.server_name)[0]
server_resp = gb.acceptSecContext(self.client_token1,
acceptor_cred=self.server_creds)
self.server_ctx = server_resp[0]
self.server_tok = server_resp[3]
client_resp2 = gb.initSecContext(self.target_name,
context=self.client_ctx,
input_token=self.server_tok)
self.client_token2 = client_resp2[3]
self.client_ctx = client_resp2[0]
def __new__(cls,
name,
name_type=gss.NameType.hostbased_service,
base_name=None):
if base_name is None:
base_res = gss.importName(name.encode('utf-8'), name_type)
else:
base_res = base_name
return super(GSSName, cls).__new__(cls, base_res)
def setUp(self):
self.target_name = gb.importName(TARGET_SERVICE_NAME)
ctx_resp = gb.initSecContext(self.target_name)
self.client_token1 = ctx_resp[3]
self.client_ctx = ctx_resp[0]
str_server_name = (TARGET_SERVICE_NAME + b'/' +
socket.getfqdn().encode('utf-8'))
self.server_name = gb.importName(str_server_name,
gb.NameType.principal)
self.server_creds = gb.acquireCred(self.server_name)[0]
server_resp = gb.acceptSecContext(self.client_token1,
acceptor_cred=self.server_creds)
self.server_ctx = server_resp[0]
self.server_tok = server_resp[3]
client_resp2 = gb.initSecContext(self.target_name,
context=self.client_ctx,
input_token=self.server_tok)
self.client_token2 = client_resp2[3]
self.client_ctx = client_resp2[0]
def setUp(self):
self.target_name = gb.importName(TARGET_SERVICE_NAME)
ctx_resp = gb.initSecContext(self.target_name)
self.client_token1 = ctx_resp[3]
self.client_ctx = ctx_resp[0]
str_server_name = (TARGET_SERVICE_NAME + b'/' +
socket.getfqdn().encode('utf-8'))
self.server_name = gb.importName(str_server_name,
gb.NameType.principal)
self.server_creds = gb.acquireCred(self.server_name)[0]
server_resp = gb.acceptSecContext(self.client_token1,
acceptor_cred=self.server_creds)
self.server_ctx = server_resp[0]
self.server_tok = server_resp[3]
client_resp2 = gb.initSecContext(self.target_name,
context=self.client_ctx,
input_token=self.server_tok)
self.client_token2 = client_resp2[3]
self.client_ctx = client_resp2[0]
def test_context_time(self):
target_name = gb.importName(TARGET_SERVICE_NAME)
ctx_resp = gb.initSecContext(target_name)
client_token1 = ctx_resp[3]
client_ctx = ctx_resp[0]
server_name = gb.importName(SERVICE_PRINCIPAL,
gb.NameType.principal)
server_creds = gb.acquireCred(server_name)[0]
server_resp = gb.acceptSecContext(client_token1,
acceptor_cred=server_creds)
server_tok = server_resp[3]
client_resp2 = gb.initSecContext(target_name,
context=client_ctx,
input_token=server_tok)
ctx = client_resp2[0]
ttl = gb.contextTime(ctx)
ttl.should_be_an_integer()
ttl.should_be_greater_than(0)
def test_context_time(self):
target_name = gb.importName(TARGET_SERVICE_NAME)
ctx_resp = gb.initSecContext(target_name)
client_token1 = ctx_resp[3]
client_ctx = ctx_resp[0]
str_server_name = (TARGET_SERVICE_NAME + b'/' +
socket.getfqdn().encode('utf-8'))
server_name = gb.importName(str_server_name, gb.NameType.principal)
server_creds = gb.acquireCred(server_name)[0]
server_resp = gb.acceptSecContext(client_token1,
acceptor_cred=server_creds)
server_tok = server_resp[3]
client_resp2 = gb.initSecContext(target_name,
context=client_ctx,
input_token=server_tok)
ctx = client_resp2[0]
ttl = gb.contextTime(ctx)
ttl.should_be_an_integer()
ttl.should_be_greater_than(0)
def test_display_name(self):
imported_name = gb.importName(TARGET_SERVICE_NAME)
displ_resp = gb.displayName(imported_name)
displ_resp.shouldnt_be_none()
(displayed_name, out_type) = displ_resp
displayed_name.shouldnt_be_none()
displayed_name.should_be_a(bytes)
displayed_name.should_be(TARGET_SERVICE_NAME)
out_type.shouldnt_be_none()
out_type.should_be(gb.NameType.hostbased_service)
def test_display_name(self):
imported_name = gb.importName(TARGET_SERVICE_NAME)
displ_resp = gb.displayName(imported_name)
displ_resp.shouldnt_be_none()
(displayed_name, out_type) = displ_resp
displayed_name.shouldnt_be_none()
displayed_name.should_be_a(bytes)
displayed_name.should_be(TARGET_SERVICE_NAME)
out_type.shouldnt_be_none()
out_type.should_be(gb.NameType.hostbased_service)
def test_canonicalize_export_name(self):
imported_name = gb.importName(INITIATOR_PRINCIPAL,
gb.NameType.principal)
canonicalized_name = gb.canonicalizeName(imported_name,
gb.MechType.kerberos)
canonicalized_name.shouldnt_be_none()
canonicalized_name.should_be_a(gb.Name)
exported_name = gb.exportName(canonicalized_name)
exported_name.shouldnt_be_none()
exported_name.should_be_a(bytes)
exported_name.shouldnt_be_empty()
def test_canonicalize_export_name(self):
imported_name = gb.importName(INITIATOR_PRINCIPAL,
gb.NameType.principal)
canonicalized_name = gb.canonicalizeName(imported_name,
gb.MechType.kerberos)
canonicalized_name.shouldnt_be_none()
canonicalized_name.should_be_a(gb.Name)
exported_name = gb.exportName(canonicalized_name)
exported_name.shouldnt_be_none()
exported_name.should_be_a(bytes)
exported_name.shouldnt_be_empty()
def test_acquire_creds(self):
name = gb.importName(SERVICE_PRINCIPAL,
gb.NameType.principal)
cred_resp = gb.acquireCred(name)
cred_resp.shouldnt_be_none()
(creds, actual_mechs, ttl) = cred_resp
creds.shouldnt_be_none()
creds.should_be_a(gb.Creds)
actual_mechs.shouldnt_be_empty()
actual_mechs.should_include(gb.MechType.kerberos)
ttl.should_be_an_integer()
gb.releaseName(name)
gb.releaseCred(creds)
def test_acquire_creds(self):
name = gb.importName(
(TARGET_SERVICE_NAME + b'/' + socket.getfqdn().encode('utf-8')),
gb.NameType.principal)
cred_resp = gb.acquireCred(name)
cred_resp.shouldnt_be_none()
(creds, actual_mechs, ttl) = cred_resp
creds.shouldnt_be_none()
creds.should_be_a(gb.Creds)
actual_mechs.shouldnt_be_empty()
actual_mechs.should_include(gb.MechType.kerberos)
ttl.should_be_an_integer()
gb.releaseName(name)
gb.releaseCred(creds)
def test_acquire_creds(self):
name = gb.importName((TARGET_SERVICE_NAME + b'/' +
socket.getfqdn().encode('utf-8')),
gb.NameType.principal)
cred_resp = gb.acquireCred(name)
cred_resp.shouldnt_be_none()
(creds, actual_mechs, ttl) = cred_resp
creds.shouldnt_be_none()
creds.should_be_a(gb.Creds)
actual_mechs.shouldnt_be_empty()
actual_mechs.should_include(gb.MechType.kerberos)
ttl.should_be_an_integer()
gb.releaseName(name)
gb.releaseCred(creds)
def setUp(self):
self.target_name = gb.importName(TARGET_SERVICE_NAME)
def test_duplicate_name(self):
orig_name = gb.importName(TARGET_SERVICE_NAME)
new_name = gb.duplicateName(orig_name)
new_name.shouldnt_be_none()
gb.compareName(orig_name, new_name).should_be_true()
def setUp(self):
self.target_name = gb.importName(TARGET_SERVICE_NAME)
def test_duplicate_name(self):
orig_name = gb.importName(TARGET_SERVICE_NAME)
new_name = gb.duplicateName(orig_name)
new_name.shouldnt_be_none()
gb.compareName(orig_name, new_name).should_be_true()
