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; }