mit_krb5_error_code KRB5_CALLCONV
krb5_verify_init_creds(mit_krb5_context context,
mit_krb5_creds *creds,
mit_krb5_principal ap_req_server,
mit_krb5_keytab ap_req_keytab,
mit_krb5_ccache *ccache,
mit_krb5_verify_init_creds_opt *options)
{
struct comb_principal *p = (struct comb_principal *)ap_req_server;
krb5_error_code ret;
krb5_creds hcreds;
krb5_verify_init_creds_opt hopts;
memset(&hcreds, 0, sizeof(hcreds));
heim_krb5_verify_init_creds_opt_init(&hopts);
if (options->ap_req_nofail)
heim_krb5_verify_init_creds_opt_set_ap_req_nofail(&hopts, options->ap_req_nofail);
mshim_mcred2hcred(HC(context), creds, &hcreds);
ret = heim_krb5_verify_init_creds(HC(context),
&hcreds, p->heim,
(krb5_keytab)ap_req_keytab,
(krb5_ccache *)ccache,
&hopts);
heim_krb5_free_cred_contents(HC(context), &hcreds);
return ret;
}
mit_krb5_error_code KRB5_CALLCONV
krb5_get_init_creds_keytab(mit_krb5_context context,
mit_krb5_creds *creds,
mit_krb5_principal client,
mit_krb5_keytab arg_keytab,
mit_krb5_deltat start_time,
char *in_tkt_service,
mit_krb5_get_init_creds_opt *mopt)
{
struct comb_principal *p = (struct comb_principal *)client;
krb5_get_init_creds_opt *opt = NULL;
krb5_error_code ret;
krb5_creds hcreds;
LOG_ENTRY();
opt = mshim_gic_opt(HC(context), mopt);
memset(creds, 0, sizeof(*creds));
memset(&hcreds, 0, sizeof(hcreds));
ret = heim_krb5_get_init_creds_keytab(HC(context), &hcreds, p->heim,
(krb5_keytab)arg_keytab,
start_time, in_tkt_service, opt);
if (opt)
heim_krb5_get_init_creds_opt_free(HC(context), opt);
if (ret)
return ret;
mshim_hcred2mcred(HC(context), &hcreds, creds);
heim_krb5_free_cred_contents(HC(context), &hcreds);
return ret;
}
mit_krb5_error_code KRB5_CALLCONV
krb5_c_string_to_key(mit_krb5_context context,
mit_krb5_enctype enctype,
const mit_krb5_data *string,
const mit_krb5_data *salt,
mit_krb5_keyblock *key)
{
krb5_data hstring;
krb5_error_code ret;
krb5_salt hsalt;
krb5_keyblock hkey;
LOG_ENTRY();
mshim_mdata2hdata(string, &hstring);
hsalt.salttype = (krb5_salttype)KRB5_PADATA_PW_SALT;
mshim_mdata2hdata(salt, &hsalt.saltvalue);
ret = heim_krb5_string_to_key_data_salt(HC(context), enctype,
hstring, hsalt, &hkey);
heim_krb5_data_free(&hstring);
heim_krb5_data_free(&hsalt.saltvalue);
if (ret)
return ret;
mshim_hkeyblock2mkeyblock(&hkey, key);
heim_krb5_free_keyblock_contents(HC(context), &hkey);
return 0;
}
mit_krb5_error_code KRB5_CALLCONV
krb5_set_default_tgs_enctypes(mit_krb5_context context,
const mit_krb5_enctype *enc)
{
LOG_ENTRY();
return heim_krb5_set_default_in_tkt_etypes(HC(context), (krb5_enctype *)enc);
}
mit_krb5_error_code KRB5_CALLCONV
mit_krb5_os_localaddr(mit_krb5_context context, mit_krb5_address ***addresses)
{
mit_krb5_address **a;
krb5_addresses addrs;
krb5_error_code ret;
unsigned i;
LOG_ENTRY();
*addresses = NULL;
addrs.len = 0;
addrs.val = NULL;
ret = heim_krb5_get_all_client_addrs(HC(context), &addrs);
if (ret)
return ret;
a = calloc(addrs.len + 1, sizeof(a[0]));
for (i = 0; i < addrs.len; i++) {
a[i] = calloc(1, sizeof(mit_krb5_address));
a[i]->addrtype = addrs.val[i].addr_type;
a[i]->length = addrs.val[i].address.length;
a[i]->contents = mshim_malloc(addrs.val[i].address.length);
memcpy(a[i]->contents, addrs.val[i].address.data, addrs.val[i].address.length);
}
a[i] = NULL;
return 0;
}
mit_krb5_error_code KRB5_CALLCONV
krb5_kt_get_name(mit_krb5_context context,
mit_krb5_keytab keytab,
char *name,
unsigned int namelen)
{
return heim_krb5_kt_get_name(HC(context), (krb5_keytab)keytab, name, namelen);
}
mit_krb5_error_code KRB5_CALLCONV
mit_krb5_set_real_time(mit_krb5_context context,
mit_krb5_timestamp ts,
mit_krb5_int32 usec)
{
LOG_ENTRY();
return heim_krb5_set_real_time(HC(context), ts, usec);
}
mit_krb5_error_code KRB5_CALLCONV
krb5_principal2salt(mit_krb5_context context,
mit_krb5_const_principal principal,
mit_krb5_data *salt)
{
struct comb_principal *c = (struct comb_principal *)principal;
krb5_error_code ret;
krb5_salt hsalt;
memset(salt, 0, sizeof(*salt));
ret = heim_krb5_get_pw_salt(HC(context), c->heim, &hsalt);
if (ret)
return ret;
mshim_hdata2mdata(&hsalt.saltvalue, salt);
heim_krb5_free_salt(HC(context), hsalt);
return 0;
}
mit_krb5_boolean KRB5_CALLCONV
krb5_realm_compare(mit_krb5_context context,
mit_krb5_const_principal p1,
mit_krb5_const_principal p2)
{
struct comb_principal *c1 = (struct comb_principal *)p1;
struct comb_principal *c2 = (struct comb_principal *)p2;
return heim_krb5_realm_compare(HC(context), c1->heim, c2->heim);
}
mit_krb5_error_code KRB5_CALLCONV
krb5_copy_principal(mit_krb5_context context,
mit_krb5_const_principal from,
mit_krb5_principal *to)
{
struct comb_principal *p = (struct comb_principal *)from;
LOG_ENTRY();
*to = mshim_hprinc2mprinc(HC(context), p->heim);
return 0;
}
mit_krb5_error_code KRB5_CALLCONV
mit_krb5_get_validated_creds(mit_krb5_context context,
mit_krb5_creds *creds,
mit_krb5_principal client,
mit_krb5_ccache ccache,
char *in_tkt_service)
{
struct comb_principal *p = (struct comb_principal *)client;
krb5_error_code ret;
krb5_creds hcreds;
LOG_ENTRY();
mshim_mcred2hcred(HC(context), creds, &hcreds);
ret = heim_krb5_get_validated_creds(HC(context), &hcreds, p->heim,
(krb5_ccache)ccache, in_tkt_service);
heim_krb5_free_cred_contents(HC(context), &hcreds);
return ret;
}
void KRB5_CALLCONV
krb5_free_principal(mit_krb5_context context, mit_krb5_principal principal)
{
struct comb_principal *p = (struct comb_principal *)principal;
LOG_ENTRY();
if (p) {
heim_krb5_free_principal(HC(context), p->heim);
free(p->mit.data);
free(p);
}
}
mit_krb5_error_code KRB5_CALLCONV
krb5_c_encrypt(mit_krb5_context context,
const mit_krb5_keyblock *key,
mit_krb5_keyusage usage,
const mit_krb5_data *ivec,
const mit_krb5_data *input,
mit_krb5_enc_data *output)
{
LOG_ENTRY();
krb5_error_code ret;
krb5_crypto crypto;
krb5_keyblock keyblock;
krb5_data odata;
mshim_mkeyblock2hkeyblock(key, &keyblock);
ret = heim_krb5_crypto_init(HC(context), &keyblock, 0, &crypto);
heim_krb5_free_keyblock_contents(HC(context), &keyblock);
if (ret)
return ret;
if (ivec) {
size_t blocksize;
ret = heim_krb5_crypto_getblocksize(HC(context), crypto, &blocksize);
if (ret) {
heim_krb5_crypto_destroy(HC(context), crypto);
return ret;
}
if (blocksize > ivec->length) {
heim_krb5_crypto_destroy(HC(context), crypto);
return KRB5_BAD_MSIZE;
}
}
ret = heim_krb5_encrypt_ivec(HC(context), crypto, usage,
input->data, input->length,
&odata,
ivec ? ivec->data : NULL);
// output->magic = KV5M_ENC_DATA;
output->kvno = 0;
if (ret == 0) {
heim_krb5_crypto_getenctype(HC(context), crypto, &output->enctype);
mshim_hdata2mdata(&odata, &output->ciphertext);
heim_krb5_data_free(&odata);
}
heim_krb5_crypto_destroy(HC(context), crypto);
return ret ;
}
mit_krb5_error_code KRB5_CALLCONV
krb5_sname_to_principal(mit_krb5_context context,
const char *hostname, const char *service,
mit_krb5_int32 type,
mit_krb5_principal *principal)
{
krb5_error_code ret;
krb5_principal p;
LOG_ENTRY();
*principal = NULL;
ret = heim_krb5_sname_to_principal(HC(context), hostname, service, type, &p);
if (ret)
return ret;
*principal = mshim_hprinc2mprinc(HC(context), p);
heim_krb5_free_principal(HC(context), p);
return 0;
}
mit_krb5_error_code KRB5_CALLCONV
mit_krb5_get_renewed_creds (mit_krb5_context context,
mit_krb5_creds *creds,
mit_krb5_principal client,
mit_krb5_ccache ccache,
char *in_tkt_service)
{
struct comb_principal *p = (struct comb_principal *)client;
krb5_error_code ret;
krb5_creds hcreds;
LOG_ENTRY();
memset(&hcreds, 0, sizeof(hcreds));
ret = heim_krb5_get_renewed_creds(HC(context), &hcreds, p->heim, (krb5_ccache)ccache,
in_tkt_service);
if (ret == 0)
mshim_hcred2mcred(HC(context), &hcreds, creds);
heim_krb5_free_cred_contents(HC(context), &hcreds);
return ret;
}
mit_krb5_error_code KRB5_CALLCONV
krb5_get_in_tkt_with_password(mit_krb5_context context,
mit_krb5_flags flags,
mit_krb5_address * const *addr,
mit_krb5_enctype *enctype,
mit_krb5_preauthtype *preauth,
const char *password,
mit_krb5_ccache cache,
mit_krb5_creds *cred,
mit_krb5_kdc_rep **rep)
{
struct comb_principal *p;
krb5_error_code ret;
krb5_creds hcreds;
LOG_ENTRY();
if (rep)
*rep = NULL;
if (cred->client)
p = (struct comb_principal *)cred->client;
else
return KRB5_PRINC_NOMATCH;
memset(&hcreds, 0, sizeof(hcreds));
ret = heim_krb5_get_init_creds_password(HC(context), &hcreds, p->heim, password,
NULL, NULL, 0, NULL, NULL);
if (ret)
return ret;
if (cache)
heim_krb5_cc_store_cred(HC(context), (krb5_ccache)cache, &hcreds);
heim_krb5_free_cred_contents(HC(context), &hcreds);
return 0;
}
mit_krb5_error_code KRB5_CALLCONV
krb5_kt_end_seq_get(mit_krb5_context context, mit_krb5_keytab keytab,
mit_krb5_kt_cursor *cursor)
{
krb5_error_code ret;
LOG_ENTRY();
ret = heim_krb5_kt_end_seq_get(HC(context), (krb5_keytab)keytab, (krb5_kt_cursor *)*cursor);
free(*cursor);
*cursor = NULL;
return ret;
}
mit_krb5_error_code KRB5_CALLCONV
krb5_get_realm_domain(mit_krb5_context context, const char *realm, char **domain)
{
const char *d;
d = heim_krb5_config_get_string(HC(context), NULL, "realms", realm,
"default_realm", NULL);
if (d == NULL) {
*domain = NULL;
return (-1429577726L); /* PROF_NO_SECTION */
}
*domain = strdup(d);
return 0;
}
mit_krb5_error_code KRB5_CALLCONV
krb5_auth_con_getlocalsubkey(mit_krb5_context context,
mit_krb5_auth_context ac,
mit_krb5_keyblock **key)
{
LOG_ENTRY();
krb5_keyblock *hkey = NULL;
krb5_error_code ret;
*key = NULL;
ret = heim_krb5_auth_con_getlocalsubkey(HC(context),
(krb5_auth_context)ac,
&hkey);
if (ret)
return ret;
if (hkey) {
*key = mshim_malloc(sizeof(**key));
mshim_hkeyblock2mkeyblock(hkey, *key);
heim_krb5_free_keyblock(HC(context), hkey);
}
return 0;
}
mit_krb5_error_code KRB5_CALLCONV
krb5_c_encrypt_length(mit_krb5_context context,
mit_krb5_enctype enctype,
size_t inputlen, size_t *length)
{
LOG_ENTRY();
krb5_error_code ret;
krb5_crypto crypto;
krb5_keyblock key;
ret = heim_krb5_generate_random_keyblock(HC(context), enctype, &key);
if (ret)
return ret;
ret = heim_krb5_crypto_init(HC(context), &key, 0, &crypto);
heim_krb5_free_keyblock_contents(HC(context), &key);
if (ret)
return ret;
*length = heim_krb5_get_wrapped_length(HC(context), crypto, inputlen);
heim_krb5_crypto_destroy(HC(context), crypto);
return 0;
}
mit_krb5_error_code KRB5_CALLCONV
krb5_kt_next_entry(mit_krb5_context context, mit_krb5_keytab keytab,
mit_krb5_keytab_entry *entry, mit_krb5_kt_cursor *cursor)
{
krb5_error_code ret;
krb5_keytab_entry e;
LOG_ENTRY();
ret = heim_krb5_kt_next_entry(HC(context), (krb5_keytab)keytab,
&e, (krb5_kt_cursor *)*cursor);
if (ret)
return ret;
entry->magic = 0;
entry->principal = mshim_hprinc2mprinc(HC(context), e.principal);
entry->timestamp = e.timestamp;
entry->vno = e.vno;
mshim_hkeyblock2mkeyblock(&e.keyblock, &entry->key);
heim_krb5_kt_free_entry(HC(context), &e);
return 0;
}
const char * KRB5_CALLCONV
krb5_kt_get_type(mit_krb5_context context, mit_krb5_keytab id)
{
krb5_error_code ret;
static char name[80];
LOG_ENTRY();
ret = heim_krb5_kt_get_type (HC(context),
(krb5_keytab)id,
name,
sizeof(name));
if (ret)
name[0] = '\0';
return name;
}
mit_krb5_error_code KRB5_CALLCONV
krb5_kt_start_seq_get(mit_krb5_context context, mit_krb5_keytab keytab,
mit_krb5_kt_cursor *cursor)
{
krb5_error_code ret;
LOG_ENTRY();
*cursor = calloc(1, sizeof(krb5_kt_cursor));
ret = heim_krb5_kt_start_seq_get(HC(context), (krb5_keytab)keytab, (krb5_kt_cursor *)*cursor);
if (ret) {
free(*cursor);
*cursor = NULL;
}
return ret;
}
mit_krb5_error_code KRB5_LIB_FUNCTION
krb5_kt_remove_entry(mit_krb5_context context,
mit_krb5_keytab id,
mit_krb5_keytab_entry *entry)
{
struct comb_principal *p = (struct comb_principal *)entry->principal;
krb5_keytab_entry e;
LOG_ENTRY();
memset(&e, 0, sizeof(e));
e.principal = p->heim;
e.vno = entry->vno;
e.timestamp = entry->timestamp;
return heim_krb5_kt_remove_entry(HC(context), (krb5_keytab)id, &e);
}
static krb5_get_init_creds_opt *
mshim_gic_opt(krb5_context context, mit_krb5_get_init_creds_opt *mopt)
{
krb5_get_init_creds_opt *opt = NULL;
if (mopt) {
heim_krb5_get_init_creds_opt_alloc(context, &opt);
if (mopt->flags & MIT_KRB5_GET_INIT_CREDS_OPT_FORWARDABLE)
heim_krb5_get_init_creds_opt_set_forwardable(opt, mopt->forwardable);
if (mopt->flags & MIT_KRB5_GET_INIT_CREDS_OPT_PROXIABLE)
heim_krb5_get_init_creds_opt_set_proxiable(opt, mopt->proxiable);
if (mopt->flags & MIT_KRB5_GET_INIT_CREDS_OPT_CANONICALIZE)
heim_krb5_get_init_creds_opt_set_canonicalize(HC(context), opt, TRUE);
if (mopt->flags & MIT_KRB5_GET_INIT_CREDS_OPT_TKT_LIFE)
heim_krb5_get_init_creds_opt_set_tkt_life(opt, mopt->tkt_life);
if (mopt->flags & MIT_KRB5_GET_INIT_CREDS_OPT_RENEW_LIFE)
heim_krb5_get_init_creds_opt_set_renew_life(opt, mopt->renew_life);
/* XXX */
}
return opt;
}
mit_krb5_error_code KRB5_CALLCONV
krb5_kt_add_entry(mit_krb5_context context,
mit_krb5_keytab id,
mit_krb5_keytab_entry *entry)
{
struct comb_principal *p = (struct comb_principal *)entry->principal;
krb5_keytab_entry e;
LOG_ENTRY();
memset(&e, 0, sizeof(e));
e.principal = p->heim;
e.vno = entry->vno;
e.timestamp = entry->timestamp;
e.keyblock.keytype = entry->key.enctype;
e.keyblock.keyvalue.data = entry->key.contents;
e.keyblock.keyvalue.length = entry->key.length;
return heim_krb5_kt_add_entry(HC(context), (krb5_keytab)id, &e);
}
mit_krb5_error_code KRB5_CALLCONV
krb5_get_init_creds_password(mit_krb5_context context,
mit_krb5_creds *creds,
mit_krb5_principal client,
char *password,
mit_krb5_prompter_fct prompter,
void *data,
mit_krb5_deltat start_time,
char *in_tkt_service,
mit_krb5_get_init_creds_opt *mopt)
{
struct comb_principal *p = (struct comb_principal *)client;
krb5_get_init_creds_opt *opt = NULL;
krb5_error_code ret;
krb5_creds hcreds;
krb5_prompter_fct pfct = NULL;
LOG_ENTRY();
opt = mshim_gic_opt(HC(context), mopt);
memset(creds, 0, sizeof(*creds));
memset(&hcreds, 0, sizeof(hcreds));
if (prompter == krb5_prompter_posix)
pfct = heim_krb5_prompter_posix;
else if (prompter == NULL)
pfct = NULL;
else {
if (opt)
heim_krb5_get_init_creds_opt_free(HC(context), opt);
return EINVAL;
}
ret = heim_krb5_get_init_creds_password(HC(context), &hcreds, p->heim, password,
pfct, NULL, start_time, in_tkt_service, opt);
if (opt)
heim_krb5_get_init_creds_opt_free(HC(context), opt);
if (ret)
return ret;
mshim_hcred2mcred(HC(context), &hcreds, creds);
heim_krb5_free_cred_contents(HC(context), &hcreds);
return ret;
}
void KRB5_CALLCONV
mit_krb5_free_context(mit_krb5_context context)
{
LOG_ENTRY();
heim_krb5_free_context(HC(context));
}
int main()
{
printf("\a\t\tIFPB - Campus Joao Pessoa\n");
printf("\t\tCurso Superior de Engenharia Eletrica\n");
printf("\t\tDisciplina de Algoritmos e Logica de Programacao\n");
printf("\t\tProfessor: Erick\n");
printf("\t\tProva 2: Parte 2, Jogo de Batalha Naval\n");
printf("\t\tGrupo: Paulo Felipe, Josivaldo Gomes e Marcello Aires\n\n");
printf("\n--------------------------------------------------------------------------------\n");
char M[N][N], MB[N][N];
int i, j, opcao, ME[N][N]={};
GerarEspiral(ME);
ZeraT(M, MB);//JOGADOR 1
opcao = Menu();
if(opcao==1)
{
HH(MB);
contpos = cont(MB);
printf("\nSecao de Jogadas do Jogador 1\n\n");
for(i=0;i<N*N;i++)
{
Imprimir(M);
Jogada(M, MB, 0);
printf("\nQuantidade de Jogadas: %d\nQuantidade de Acertos: %d\nQuantidade Total de Posicoes de Barco: %d\n\n", contjog1, cont1, contpos);
if(contpos == cont1)
break;
}
Imprimir(M);
printf("\n\nSECAO DE JOGADAS DO JOGADOR 1 TERMINADA\n\n");
}
else if(opcao==2)
{
CH(MB);
contpos = cont(MB);
printf("\nSecao de Jogadas do Jogador 1\n\n");
for(i=0;i<N*N;i++)
{
Imprimir(M);
Jogada(M, MB, 0);
printf("\nQuantidade de Jogadas: %d\nQuantidade de Acertos: %d\nQuantidade Total de Posicoes de Barco: %d\n\n", contjog1, cont1, contpos);
if(contpos == cont1)
break;
}
Imprimir(M);
printf("\n\nSECAO DE JOGADAS DO JOGADOR 1 TERMINADA\n\n");
}
else if(opcao==3)
{
int X, Y, i, estado = 0, ult=0;
HC(MB, M);
contpos = cont(MB);
for(i=0;i<N*N;i++)
{
do
{
estado = 0;
X = (rand()%N);//VAI DE 0 A N-1
Y = (rand()%N);//VAI DE 0 A N-1
if(MB[X][Y]=='~' && M[X][Y]=='~')
{
M[X][Y] = '*';
contjog1++;
estado = 1;
}
else if(MB[X][Y]=='B' && M[X][Y]=='~')
{
M[X][Y] = 'X';
contjog1++;
cont1++;
i += AcertouNavio(M, MB, X, Y, 0);
estado = 1;
}
}while(estado!=1);
ImprimirAux(0);
Imprimir(M);
if(cont1==contpos)
{
printf("\n\nSECAO DE JOGADAS DO JOGADOR 1 TERMINADA\n\n");
break;
}
}
}
ZeraT(M, MB);//JOGADOR 2
opcao = Menu();
if(opcao==1)
{
HH(MB);
contpos = cont(MB);
printf("\nSecao de Jogadas do Jogador 2\n\n");
for(i=0;i<N*N;i++)
{
Imprimir(M);
Jogada(M, MB, 1);
printf("\nQuantidade de Jogadas: %d\nQuantidade de Acertos: %d\nQuantidade Total de Posicoes de Barco: %d\n\n", contjog2, cont2, contpos);
if(contpos == cont2)
break;
}
Imprimir(M);
printf("\n\nSECAO DE JOGADAS DO JOGADOR 2 TERMINADA\n\n");
}
else if(opcao==2)
{
CH(MB);
contpos = cont(MB);
printf("\nSecao de Jogadas do Jogador 2\n\n");
for(i=0;i<N*N;i++)
{
Imprimir(M);
Jogada(M, MB, 1);
printf("\nQuantidade de Jogadas: %d\nQuantidade de Acertos: %d\nQuantidade Total de Posicoes de Barco: %d\n\n", contjog2, cont2, contpos);
if(contpos == cont2)
break;
}
Imprimir(M);
printf("\n\nSECAO DE JOGADAS DO JOGADOR 2 TERMINADA\n\n");
}
else if(opcao==3)
{
int X, Y, i, estado = 0, ult=0;
HC(MB, M);
contpos = cont(MB);
for(i=0;i<N*N;i++)
{
do
{
estado = 0;
X = (rand()%N);//VAI DE 0 A N-1
Y = (rand()%N);//VAI DE 0 A N-1
if(MB[X][Y]=='~' && M[X][Y]=='~')
{
M[X][Y] = '*';
contjog2++;
estado = 1;
}
else if(MB[X][Y]=='B' && M[X][Y]=='~')
{
M[X][Y] = 'X';
contjog2++;
cont2++;
i+=AcertouNavio(M, MB, X, Y, 1);
estado = 1;
}
}while(estado!=1);
ImprimirAux(1);
Imprimir(M);
if(cont2==contpos)
{
printf("\n\nSECAO DE JOGADAS DO JOGADOR 2 TERMINADA\n\n");
break;
}
}
}
if(contjog1<contjog2)
printf("\nJOGADOR 1 VENCEU!!! %d x %d\n\n", contjog1, contjog2);
else if(contjog1>contjog2)
printf("\nJOGADOR 2 VENCEU!!! %d x %d\n\n", contjog2, contjog1);
else
printf("\nJOGO EMPATADO!!! %d x %d\n\n", contjog1, contjog2);
return 0;
}
