static void lib_md_init(mrb_state *mrb, struct mrb_md *md, int type) { int ctxsize; ctxsize = md_ctx_size(type); if (ctxsize == 0) { mrb_raise(mrb, E_NOTIMP_ERROR, "not supported"); } md->type = type; md->ctx = NULL; md->ctx = mrb_malloc(mrb, ctxsize); md_init(type, md->ctx); }
track_t *track_alloc(const char *fn) { track_t *track = (track_t *)malloc(sizeof(track_t)); str_init(&track->fn); str_puts(&track->fn, fn); md_init(&track->md); au_init(&track->au); track->avail = false; /* track is unavailable until its format is found */ track->sane = true; /* track is sane until decoding it fails */ return track; }
/* * generate new key from all the pools */ static void reseed(FState * st) { unsigned k; unsigned n; MD_CTX key_md; unsigned char buf[BLOCK]; /* set pool as empty */ st->pool0_bytes = 0; /* * Both #0 and #1 reseed would use only pool 0. Just skip #0 then. */ n = ++st->reseed_count; /* * The goal: use k-th pool only 1/(2^k) of the time. */ md_init(&key_md); for (k = 0; k < NUM_POOLS; k++) { md_result(&st->pool[k], buf); md_update(&key_md, buf, BLOCK); if (n & 1 || !n) break; n >>= 1; } /* add old key into mix too */ md_update(&key_md, st->key, BLOCK); /* add pid to make output diverse after fork() */ md_update(&key_md, (const unsigned char *)&st->pid, sizeof(st->pid)); /* now we have new key */ md_result(&key_md, st->key); /* use new key */ ciph_init(&st->ciph, st->key, BLOCK); memset(&key_md, 0, sizeof(key_md)); memset(buf, 0, BLOCK); }
/* * generate new key from all the pools */ static void reseed(FState *st) { unsigned k; unsigned n; mdCtx key_md; uint8_t buf[block]; /* set pool as empty */ st->pool0Bytes = 0; /* * Both #0 and #1 reseed would use only pool 0. Just skip #0 then. */ n = ++st->reseedCount; /* * The goal: use k-th pool only 1/(2^k) of the time. */ md_init(&key_md); for (k = 0; k < numPools; k++) { md_result(&st->pool[k], buf); md_update(&key_md, buf, block); if (n & 1 || !n) break; n >>= 1; } /* add old key into mix too */ md_update(&key_md, st->key, block); /* now we have new key */ md_result(&key_md, st->key); /* use new key */ ciph_init(&st->ciph, st->key, block); memset(&key_md, 0, sizeof(key_md)); memset(buf, 0, block); }
// program execution starts here! int main( int argc, char** argv ) { curl_global_init(CURL_GLOBAL_ALL); // start up protocol buffers GOOGLE_PROTOBUF_VERIFY_VERSION; g_config_file = strdup( METADATA_DEFAULT_CONFIG ); // process command-line options int c; int rc; bool make_daemon = true; bool good_input = true; char* mc_root = NULL; char* logfile = NULL; char* pidfile = NULL; int portnum = 0; int reload_pid = 0; while((c = getopt(argc, argv, "fc:m:p:u:l:P:k:")) != -1) { switch( c ) { case 'f': { make_daemon = false; break; } case '?': { usage( argv[0], 1 ); } case 'c': { g_config_file = realpath( optarg, NULL ); break; } case 'm': { mc_root = realpath( optarg, NULL ); break; } case 'P': { portnum = strtol( optarg, NULL, 10 ); if( portnum <= 0 ) good_input = false; break; } case 'u': { g_secrets_file = realpath( optarg, NULL ); break; } case 'l': { logfile = strdup( optarg ); break; } case 'p': { pidfile = realpath( optarg, NULL ); break; } case 'k': { reload_pid = strtol( optarg, NULL, 10 ); if( reload_pid <= 0 ) good_input = false; break; } default: { fprintf(stderr, "Ignoring unrecognized option %c\n", c); good_input = false; break; } } } if( !good_input ) { usage( argv[0], 1 ); } if( reload_pid > 0 ) { // all we're doing is telling a running metadata server to reload kill( reload_pid, SIGUSR1 ); exit(0); } // read the config struct md_syndicate_conf conf; g_conf = &conf; dbprintf("reading config %s\n", g_config_file); if( md_read_conf( g_config_file, &conf ) != 0 ) { errorf("Could not read config at %s\n", g_config_file); usage( argv[0], 1 ); } // user-given portnum? if( portnum > 0 ) { conf.portnum = portnum; } if( conf.portnum == 0 ) { errorf("Invalid port number %d. Specify PORTNUM in the config file or pass -p\n", conf.portnum); exit(1); } // master copy supplied in args? if( mc_root ) { if( conf.master_copy_root ) { free( conf.master_copy_root ); } conf.master_copy_root = mc_root; } // secrets file supplied in args? if( g_secrets_file ) { if( conf.secrets_file ) { free( conf.secrets_file ); } conf.secrets_file = g_secrets_file; } else if( conf.secrets_file ) { g_secrets_file = strdup( conf.secrets_file ); } // pidfile supplied in args? if( pidfile ) { if( conf.md_pidfile_path ) { free( conf.md_pidfile_path ); } conf.md_pidfile_path = pidfile; } dbprintf("%s", "initializing libsyndicate\n"); // set the config if( md_init( &conf, NULL ) != 0 ) exit(1); md_connect_timeout( conf.query_timeout ); md_signals( 0 ); // no signals dbprintf("reading users file %s\n", conf.secrets_file ); // read the users file struct md_user_entry **users = NULL; if( conf.secrets_file ) { users = md_parse_secrets_file( conf.secrets_file ); if( users == NULL ) { exit(1); } } else { errorf("No secrets file given. Pass -u or specify a value for %s in the config\n", SECRETS_FILE_KEY ); usage( argv[0], 1 ); } // need to daemonize? if( make_daemon ) { FILE* log = NULL; rc = md_daemonize( logfile, conf.md_pidfile_path, &log ); if( rc < 0 ) { errorf("md_daemonize rc = %d\n", rc ); exit(1); } if( log ) conf.md_logfile = log; } // setup the reload semaphore sem_init( &reload_sem, 0, 0 ); reload_thread = md_start_thread( reloader, NULL, true ); // start HTTP rc = http_init( &http, &conf, users ); if( rc != 0 ) { exit(1); } // start validator rc = validator_init( &conf ); if( rc != 0 ) { exit(1); } setup_signals(); while( 1 ) { sleep(1); } // we never reach this point--the signal handler cleans up return 0; }
/* * Implementation of the PKCS#1 v2.1 RSASSA-PSS-VERIFY function */ int rsa_rsassa_pss_verify_ext( rsa_context *ctx, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng, int mode, md_type_t md_alg, unsigned int hashlen, const unsigned char *hash, md_type_t mgf1_hash_id, int expected_salt_len, const unsigned char *sig ) { int ret; size_t siglen; unsigned char *p; unsigned char buf[POLARSSL_MPI_MAX_SIZE]; unsigned char result[POLARSSL_MD_MAX_SIZE]; unsigned char zeros[8]; unsigned int hlen; size_t slen, msb; const md_info_t *md_info; md_context_t md_ctx; if( mode == RSA_PRIVATE && ctx->padding != RSA_PKCS_V21 ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); siglen = ctx->len; if( siglen < 16 || siglen > sizeof( buf ) ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); ret = ( mode == RSA_PUBLIC ) ? rsa_public( ctx, sig, buf ) : rsa_private( ctx, f_rng, p_rng, sig, buf ); if( ret != 0 ) return( ret ); p = buf; if( buf[siglen - 1] != 0xBC ) return( POLARSSL_ERR_RSA_INVALID_PADDING ); if( md_alg != POLARSSL_MD_NONE ) { // Gather length of hash to sign // md_info = md_info_from_type( md_alg ); if( md_info == NULL ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); hashlen = md_get_size( md_info ); } md_info = md_info_from_type( mgf1_hash_id ); if( md_info == NULL ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); hlen = md_get_size( md_info ); slen = siglen - hlen - 1; /* Currently length of salt + padding */ memset( zeros, 0, 8 ); // Note: EMSA-PSS verification is over the length of N - 1 bits // msb = mpi_msb( &ctx->N ) - 1; // Compensate for boundary condition when applying mask // if( msb % 8 == 0 ) { p++; siglen -= 1; } if( buf[0] >> ( 8 - siglen * 8 + msb ) ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); md_init( &md_ctx ); md_init_ctx( &md_ctx, md_info ); mgf_mask( p, siglen - hlen - 1, p + siglen - hlen - 1, hlen, &md_ctx ); buf[0] &= 0xFF >> ( siglen * 8 - msb ); while( p < buf + siglen && *p == 0 ) p++; if( p == buf + siglen || *p++ != 0x01 ) { md_free( &md_ctx ); return( POLARSSL_ERR_RSA_INVALID_PADDING ); } /* Actual salt len */ slen -= p - buf; if( expected_salt_len != RSA_SALT_LEN_ANY && slen != (size_t) expected_salt_len ) { md_free( &md_ctx ); return( POLARSSL_ERR_RSA_INVALID_PADDING ); } // Generate H = Hash( M' ) // md_starts( &md_ctx ); md_update( &md_ctx, zeros, 8 ); md_update( &md_ctx, hash, hashlen ); md_update( &md_ctx, p, slen ); md_finish( &md_ctx, result ); md_free( &md_ctx ); if( memcmp( p + slen, result, hlen ) == 0 ) return( 0 ); else return( POLARSSL_ERR_RSA_VERIFY_FAILED ); }
int g_build_math_packet(__g_handle hdl, char *field, char oper, pmda mdm, __g_math *ret, uint32_t flags) { g_setjmp(0, "g_build_math_packet", NULL, NULL); int rt = 0; md_init(mdm, 16); __g_math p_math = (__g_math ) mdm->pos->ptr; __g_math math = (__g_math ) md_alloc(mdm, sizeof(_g_math)); if (!math) { rt = 1; goto end; } math->flags |= flags; if ((rt = g_get_math_g_t_ptr(hdl, field, math, 0, p_math))) { goto end; } if (!(math->flags & F_MATH_TYPES)) { rt = 6; goto end; } if (math->_m_p) { math->op_t = m_get_op_proc(oper, math); if ( NULL == math->op_t) { rt = 7; goto end; } /*if (oper == 0x7E) { math->flags |= F_MATH_IS_SQRT; }*/ } if (ret) { *ret = math; } end: if (rt) { md_unlink(mdm, mdm->pos); } return rt; }
/* * mainline. crack command line arguments. */ int main( int argc, char *argv[] ) { char *sname = MD_LOCAL_NAME; mdsetname_t *sp = NULL; int aflag = 0; int pflag = 0; int set_flag = 0; mdcmdopts_t options = (MDCMD_PRINT|MDCMD_DOIT); int c; md_error_t status = mdnullerror; md_error_t *ep = &status; int eval = 1; int error; bool_t called_thru_rpc = FALSE; char *cp; int mnset = FALSE; /* * Get the locale set up before calling any other routines * with messages to ouput. Just in case we're not in a build * environment, make sure that TEXT_DOMAIN gets set to * something. */ #if !defined(TEXT_DOMAIN) #define TEXT_DOMAIN "SYS_TEST" #endif (void) setlocale(LC_ALL, ""); (void) textdomain(TEXT_DOMAIN); if ((cp = strstr(argv[0], ".rpc_call")) == NULL) { if (sdssc_bind_library() == SDSSC_OKAY) if (sdssc_cmd_proxy(argc, argv, SDSSC_PROXY_PRIMARY, &error) == SDSSC_PROXY_DONE) exit(error); } else { *cp = '\0'; /* cut off ".rpc_call" */ called_thru_rpc = TRUE; } /* initialize */ if (md_init(argc, argv, 0, 1, ep) != 0 || meta_check_root(ep) != 0) goto errout; /* parse args */ optind = 1; opterr = 1; while ((c = getopt(argc, argv, "hs:afrp?")) != -1) { switch (c) { case 'h': usage(sp, 0); break; case 's': sname = optarg; set_flag++; break; case 'a': ++aflag; options |= MDCMD_FORCE; break; case 'f': options |= MDCMD_FORCE; break; case 'r': options |= MDCMD_RECURSE | MDCMD_FORCE; break; case 'p': ++pflag; break; case '?': if (optopt == '?') usage(sp, 0); /*FALLTHROUGH*/ default: usage(sp, 1); break; } } argc -= optind; argv += optind; /* with mn sets if -a, set name must have been specified by -s */ if (called_thru_rpc && aflag && !set_flag) { md_eprintf(gettext( "-a parameter requires the use of -s in multi-node sets")); md_exit(sp, 1); } /* get set context */ if ((sp = metasetname(sname, ep)) == NULL) { mde_perror(ep, ""); md_exit(sp, 1); } if (called_thru_rpc) { /* Check if the device is open on all nodes */ options |= MDCMD_MN_OPEN_CHECK; } if (aflag) { /* clear all devices */ if (argc != 0) usage(sp, 1); /* * If a MN set, we will generate a series of individual * metaclear commands which will each grab the set lock. * Therefore do not grab the set lock now. */ if (!meta_is_mn_set(sp, ep)) { /* grab set lock */ if (meta_lock(sp, TRUE, ep)) goto errout; /* check for ownership */ if (meta_check_ownership(sp, ep) != 0) goto errout; } else { mnset = TRUE; } /* reset all devices in set */ if (meta_reset_all(sp, options, ep) != 0) { if (!mnset) mde_perror(ep, ""); } else eval = 0; } else { /* * We are dealing with either a single or multiple names. * The set for the command is either denoted by the -s option * or the set of the first name. */ if (argc <= 0) usage(sp, 1); if (meta_is_mn_name(&sp, argv[0], ep)) mnset = TRUE; eval = 0; for (; (argc > 0); --argc, ++argv) { char *cname; /* * If we are dealing with a MN set and we were not * called thru an rpc call, we are just to send this * command string to the master of the set and let it * deal with it. */ if (!called_thru_rpc && mnset) { /* get the canonical name */ if (pflag) { /* * If -p, set cname to the device * argument. */ cname = Strdup(argv[0]); } else { /* * For hotspares and metadevices, set * cname to the full name, * setname/hspxxx or setname/dxxx */ cname = meta_name_getname(&sp, argv[0], META_DEVICE, ep); if (cname == NULL) { mde_perror(ep, ""); eval = 1; continue; } } if (meta_mn_send_metaclear_command(sp, cname, options, pflag, ep) != 0) { eval = 1; } Free(cname); } else { if (pflag) { /* * clear all soft partitions on named * devices */ if (meta_sp_reset_component(sp, argv[0], options, ep) != 0) { mde_perror(ep, ""); eval = 1; continue; } } else { /* * get the canonical name and * setup sp if it has been * specified as part of the * metadevice/hsp name param */ cname = meta_name_getname(&sp, argv[0], META_DEVICE, ep); if (cname == NULL) { mde_perror(ep, ""); eval = 1; continue; } /* clear named devices */ if (clear_name(&sp, cname, options, ep) != 0) { mde_perror(ep, ""); eval = 1; Free(cname); continue; } Free(cname); } } } } /* update md.cf */ if (meta_update_md_cf(sp, ep) != 0) { mde_perror(ep, ""); eval = 1; } md_exit(sp, eval); errout: mde_perror(ep, ""); md_exit(sp, eval); /*NOTREACHED*/ return (eval); }
/* * Implementation of the PKCS#1 v2.1 RSASSA-PSS-SIGN function */ int rsa_rsassa_pss_sign( rsa_context *ctx, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng, int mode, md_type_t md_alg, unsigned int hashlen, const unsigned char *hash, unsigned char *sig ) { size_t olen; unsigned char *p = sig; unsigned char salt[POLARSSL_MD_MAX_SIZE]; unsigned int slen, hlen, offset = 0; int ret; size_t msb; const md_info_t *md_info; md_context_t md_ctx; if( mode == RSA_PRIVATE && ctx->padding != RSA_PKCS_V21 ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); if( f_rng == NULL ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); olen = ctx->len; if( md_alg != POLARSSL_MD_NONE ) { // Gather length of hash to sign // md_info = md_info_from_type( md_alg ); if( md_info == NULL ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); hashlen = md_get_size( md_info ); } md_info = md_info_from_type( ctx->hash_id ); if( md_info == NULL ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); hlen = md_get_size( md_info ); slen = hlen; if( olen < hlen + slen + 2 ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); memset( sig, 0, olen ); // Generate salt of length slen // if( ( ret = f_rng( p_rng, salt, slen ) ) != 0 ) return( POLARSSL_ERR_RSA_RNG_FAILED + ret ); // Note: EMSA-PSS encoding is over the length of N - 1 bits // msb = mpi_msb( &ctx->N ) - 1; p += olen - hlen * 2 - 2; *p++ = 0x01; memcpy( p, salt, slen ); p += slen; md_init( &md_ctx ); md_init_ctx( &md_ctx, md_info ); // Generate H = Hash( M' ) // md_starts( &md_ctx ); md_update( &md_ctx, p, 8 ); md_update( &md_ctx, hash, hashlen ); md_update( &md_ctx, salt, slen ); md_finish( &md_ctx, p ); // Compensate for boundary condition when applying mask // if( msb % 8 == 0 ) offset = 1; // maskedDB: Apply dbMask to DB // mgf_mask( sig + offset, olen - hlen - 1 - offset, p, hlen, &md_ctx ); md_free( &md_ctx ); msb = mpi_msb( &ctx->N ) - 1; sig[0] &= 0xFF >> ( olen * 8 - msb ); p += hlen; *p++ = 0xBC; return( ( mode == RSA_PUBLIC ) ? rsa_public( ctx, sig, sig ) : rsa_private( ctx, f_rng, p_rng, sig, sig ) ); }
int g_process_math_string(__g_handle hdl, char *string, pmda mdm, pmda chain, int *ret, void **p_ret, uint32_t flags, uint32_t int_flags) { g_setjmp(0, "g_process_math_string", NULL, NULL); char *ptr = string, *left, oper = 0x0; size_t i; size_t sin_len = strlen(string); if (sin_len == 0) { return 0; } //g_del_char(string, string_p, 0x20); int f_ret = 0; while (ptr[0]) { if (ptr[0] == 0x0 || ptr[0] == 0x23 || ptr[0] == 0x7D || ptr[0] == 0x29 || ptr[0] == 0x3A) { if (ptr[0] == 0x29) { if (!(int_flags & F_PROC_MATH_STR_INB)) { f_ret = 0; goto f_end; } else { *p_ret = ptr; } } else { /*if ((int_flags & F_PROC_MATH_STR_INB)) { return 12; }*/ } break; } while (ptr[0] == 0x20) { ptr++; } if (ptr[0] == 0x28) { if (ptr[1] == 0x29) { break; } pmda object = (pmda) md_alloc(chain, sizeof(mda)); if (NULL == object) { f_ret = -1; goto f_end; } md_init(object, 8); char *pms_ret = ""; ptr++; int r = g_process_math_string(hdl, ptr, object, chain, ret, (void*) &pms_ret, flags, int_flags | F_PROC_MATH_STR_INB); if (0 != r) { ERROR( "g_process_math_string (F_PROC_MATH_STR_INB): FAILED: [%d]: %s\n", r, pms_ret); md_free(object); f_ret = r; goto f_end; } else { __g_math math_c = (__g_math ) m_find_last_dtype(chain, chain->pos); __g_math math = (__g_math ) md_alloc(mdm, sizeof(_g_math)); if (NULL == math) { f_ret = 16; goto f_end; } if (NULL == math_c) { f_ret = 17; goto f_end; } math->next = object; math->flags |= F_MATH_NITEM; pms_ret++; ptr = pms_ret; math->flags |= (math_c->flags & F_MATH_TYPES); __g_math math_p = (__g_math ) m_find_prev_dtype(mdm, (p_md_obj) mdm->pos); math->_m_p = g_get_math_m_p(math, math_p); if (!(is_ascii_arith_bin_oper(ptr[0]))) { if (NULL == math_c->_m_p) { f_ret = 21; goto f_end; } math->op_t = m_get_op_proc(ptr[0], math_c); if ( NULL == math->op_t) { f_ret = 22; goto f_end; } //math->_m_p = math_c->_m_p; } math->vb = math_c->vb; math->l_off = math_c->l_off; if (ptr[0] == 0x0 || ptr[0] == 0x23 || ptr[0] == 0x7D || ptr[0] == 0x3A || ptr[0] == 0x29) { continue; } ptr++; continue; } } i = 0; left = ptr; uint32_t add_flags = 0; char in_dummy[8192]; if (ptr[0] == 0x5B) { void *l_next_ref; char *s_ptr = l_mppd_shell_ex(ptr, in_dummy, sizeof(in_dummy), &l_next_ref, 0x5B, 0x5D, F_MPPD_SHX_TZERO); if (NULL == s_ptr) { f_ret = 130; goto f_end; } if (NULL == l_next_ref || ((char*) l_next_ref)[0] == 0x0) { f_ret = 131; goto f_end; } left = s_ptr; ptr = l_next_ref; add_flags |= F_MATH_STRCONV; } else { if (ptr[0] == 0x2B || ptr[0] == 0x2D) { ptr++; } while (is_ascii_arith_bin_oper(ptr[0]) && ptr[0] && ptr[0] != 0x23 && ptr[0] != 0x7D && ptr[0] != 0x29 && ptr[0] != 0x3A && ptr[0] != 0x29 && ptr[0] != 0x20) { i++; ptr++; } if (!i) { f_ret = 1; goto f_end; } } if (ptr[0] && ptr[0] != 0x23 && ptr[0] != 0x7D && ptr[0] != 0x29 && ptr[0] != 0x3A && ptr[0] != 0x29) { if (is_ascii_arith_bin_oper(ptr[0])) { f_ret = 23; goto f_end; } if (ptr[0] == 0x3C || ptr[0] == 0x3E) { if (ptr[0] != ptr[1]) { f_ret = 2; goto f_end; } ptr++; } oper = ptr[0]; ptr++; } else { oper = 0x0; } __g_math mm; *ret = g_build_math_packet(hdl, left, oper, mdm, &mm, flags | add_flags); if (*ret) { f_ret = 6; goto f_end; } if (oper == 0x7E && (ptr[0] == 0x7D || ptr[0] == 0x29)) { *ret = g_build_math_packet(hdl, left, oper, mdm, NULL, flags | add_flags); if (*ret) { f_ret = 7; goto f_end; } } } f_end: ; //free(string_p); return f_ret; }
/* * Implementation of the PKCS#1 v2.1 RSAES-OAEP-ENCRYPT function */ int rsa_rsaes_oaep_encrypt( rsa_context *ctx, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng, int mode, const unsigned char *label, size_t label_len, size_t ilen, const unsigned char *input, unsigned char *output ) { size_t olen; int ret; unsigned char *p = output; unsigned int hlen; const md_info_t *md_info; md_context_t md_ctx; if( mode == RSA_PRIVATE && ctx->padding != RSA_PKCS_V21 ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); if( f_rng == NULL ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); md_info = md_info_from_type( ctx->hash_id ); if( md_info == NULL ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); olen = ctx->len; hlen = md_get_size( md_info ); if( olen < ilen + 2 * hlen + 2 ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); memset( output, 0, olen ); *p++ = 0; // Generate a random octet string seed // if( ( ret = f_rng( p_rng, p, hlen ) ) != 0 ) return( POLARSSL_ERR_RSA_RNG_FAILED + ret ); p += hlen; // Construct DB // md( md_info, label, label_len, p ); p += hlen; p += olen - 2 * hlen - 2 - ilen; *p++ = 1; memcpy( p, input, ilen ); md_init( &md_ctx ); md_init_ctx( &md_ctx, md_info ); // maskedDB: Apply dbMask to DB // mgf_mask( output + hlen + 1, olen - hlen - 1, output + 1, hlen, &md_ctx ); // maskedSeed: Apply seedMask to seed // mgf_mask( output + 1, hlen, output + hlen + 1, olen - hlen - 1, &md_ctx ); md_free( &md_ctx ); return( ( mode == RSA_PUBLIC ) ? rsa_public( ctx, output, output ) : rsa_private( ctx, f_rng, p_rng, output, output ) ); }
/* * Implementation of the PKCS#1 v2.1 RSAES-OAEP-DECRYPT function */ int rsa_rsaes_oaep_decrypt( rsa_context *ctx, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng, int mode, const unsigned char *label, size_t label_len, size_t *olen, const unsigned char *input, unsigned char *output, size_t output_max_len ) { int ret; size_t ilen, i, pad_len; unsigned char *p, bad, pad_done; unsigned char buf[POLARSSL_MPI_MAX_SIZE]; unsigned char lhash[POLARSSL_MD_MAX_SIZE]; unsigned int hlen; const md_info_t *md_info; md_context_t md_ctx; /* * Parameters sanity checks */ if( mode == RSA_PRIVATE && ctx->padding != RSA_PKCS_V21 ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); ilen = ctx->len; if( ilen < 16 || ilen > sizeof( buf ) ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); md_info = md_info_from_type( ctx->hash_id ); if( md_info == NULL ) return( POLARSSL_ERR_RSA_BAD_INPUT_DATA ); /* * RSA operation */ ret = ( mode == RSA_PUBLIC ) ? rsa_public( ctx, input, buf ) : rsa_private( ctx, f_rng, p_rng, input, buf ); if( ret != 0 ) return( ret ); /* * Unmask data and generate lHash */ hlen = md_get_size( md_info ); md_init( &md_ctx ); md_init_ctx( &md_ctx, md_info ); /* Generate lHash */ md( md_info, label, label_len, lhash ); /* seed: Apply seedMask to maskedSeed */ mgf_mask( buf + 1, hlen, buf + hlen + 1, ilen - hlen - 1, &md_ctx ); /* DB: Apply dbMask to maskedDB */ mgf_mask( buf + hlen + 1, ilen - hlen - 1, buf + 1, hlen, &md_ctx ); md_free( &md_ctx ); /* * Check contents, in "constant-time" */ p = buf; bad = 0; bad |= *p++; /* First byte must be 0 */ p += hlen; /* Skip seed */ /* Check lHash */ for( i = 0; i < hlen; i++ ) bad |= lhash[i] ^ *p++; /* Get zero-padding len, but always read till end of buffer * (minus one, for the 01 byte) */ pad_len = 0; pad_done = 0; for( i = 0; i < ilen - 2 * hlen - 2; i++ ) { pad_done |= p[i]; pad_len += ( pad_done == 0 ); } p += pad_len; bad |= *p++ ^ 0x01; /* * The only information "leaked" is whether the padding was correct or not * (eg, no data is copied if it was not correct). This meets the * recommendations in PKCS#1 v2.2: an opponent cannot distinguish between * the different error conditions. */ if( bad != 0 ) return( POLARSSL_ERR_RSA_INVALID_PADDING ); if( ilen - ( p - buf ) > output_max_len ) return( POLARSSL_ERR_RSA_OUTPUT_TOO_LARGE ); *olen = ilen - (p - buf); memcpy( output, p, *olen ); return( 0 ); }
static void lib_md_reset(mrb_state *mrb, struct mrb_md *md) { md_init(md->type, md->ctx); }
int parse_args(int argc, char **argv, _gg_opt fref_t[], char ***la, uint32_t flags) { g_setjmp(0, "parse_args", NULL, NULL); int vi, ret, c = 0; if (ar_vref.count) { md_free(&ar_vref); } md_init(&ar_vref, 8); int i; char *c_arg = NULL; char **c_argv = NULL; __gg_opt ora = (__gg_opt) fref_t; _g_vop vop = { 0 }; errno = 0; for (i = 1, ret = 0, vi = -1; i < argc; i++, vi = -1) { c_arg = argv[i]; c_argv = &argv[i]; char *p_iseq = strchr(c_arg, 0x3D); if (p_iseq) { char bp_opt[64]; size_t p_isl = p_iseq - c_arg; p_isl > 63 ? p_isl = 63 : 0; strncpy(bp_opt, c_arg, p_isl); bp_opt[p_isl] = 0x0; p_iseq++; ret = process_opt_n(bp_opt, p_iseq, fref_t, 2, &vi, (void*) &vop); } else { ret = process_opt_n(c_arg, (char*) &argv[i + 1], fref_t, 0, &vi, (void*) &vop); } ar_check_ttl_expired(&ar_vref); ar_mod_ttl(&ar_vref, -1); if (ret == -2) { if (flags & F_PARSE_ARG_IGNORE_NOT_FOUND) { continue; } } if (0 != ret) { if (!(flags & F_PARSE_ARG_SILENT)) { if (ret == -2) { fprintf(stderr, "ERROR: [%d] invalid option '%s'\n", ret, c_arg); } else if (ret == -4) { fprintf(stderr, "ERROR: [%d] CRITICAL: improperly configured option ref table\n", ret); abort(); } else if (ret > 0) { fprintf(stderr, "ERROR: [%d] '%s': bad option argument\n", ret, c_arg); } } if (!(flags & F_PARSE_ARG_IGNORE_ERRORS)) { c = -2; break; } } else { c++; } if (NULL == p_iseq && vi > -1) { uint8_t ac = ora[vi].ac; if (0 != vop.ac_s) { ac += vop.ac_s; vop.ac_s = 0; } i += (int) ac; } } if (!(flags & F_PARSE_ARG_IGNORE_ERRORS) && !c) { return -1; } if ( NULL != la) { *la = (char**) c_argv; } return ret; }
/* * main: * The main program, of course */ int main(int argc, char **argv) { char *env; time_t lowtime; md_init(); #ifdef MASTER /* * Check to see if he is a wizard */ if (argc >= 2 && argv[1][0] == '\0') if (strcmp(PASSWD, md_crypt(md_getpass("wizard's password: "******"mT")) == 0) { wizard = TRUE; player.t_flags |= SEEMONST; argv++; argc--; } #endif /* * get home and options from environment */ strcpy(home, md_gethomedir()); if (strlen(home) > MAXSTR - strlen("rogue.save") - 1) *home = 0; strcpy(file_name, home); strcat(file_name, "rogue.save"); if ((env = getenv("ROGUEOPTS")) != NULL) parse_opts(env); if (env == NULL || whoami[0] == '\0') strucpy(whoami, md_getusername(), strlen(md_getusername())); lowtime = time(NULL); if (getenv("SEED") != NULL) { dnum = atoi(getenv("SEED")); noscore = 1; } else dnum = (unsigned int) lowtime + md_getpid(); seed = dnum; open_score(); /* * Drop setuid/setgid after opening the scoreboard file. */ md_normaluser(); /* * check for print-score option */ md_normaluser(); /* we drop any setgid/setuid priveldges here */ if (argc == 2) { if (strcmp(argv[1], "-s") == 0) { noscore = TRUE; score(0, -1, 0); exit(0); } else if (strcmp(argv[1], "-d") == 0) { dnum = rnd(100); /* throw away some rnd()s to break patterns */ while (--dnum) rnd(100); purse = rnd(100) + 1; level = rnd(100) + 1; initscr(); getltchars(); death(death_monst()); exit(0); } } init_check(); /* check for legal startup */ if (argc == 2) if (!restore(argv[1])) /* Note: restore will never return */ my_exit(1); #ifdef MASTER if (wizard) printf("Hello %s, welcome to dungeon #%d", whoami, dnum); else #endif printf("Hello %s, just a moment while I dig the dungeon...", whoami); fflush(stdout); initscr(); /* Start up cursor package */ init_probs(); /* Set up prob tables for objects */ init_player(); /* Set up initial player stats */ init_names(); /* Set up names of scrolls */ init_colors(); /* Set up colors of potions */ init_stones(); /* Set up stone settings of rings */ init_materials(); /* Set up materials of wands */ setup(); /* * The screen must be at least NUMLINES x NUMCOLS */ if (LINES < NUMLINES || COLS < NUMCOLS) { printf("\nSorry, the screen must be at least %dx%d\n", NUMLINES, NUMCOLS); endwin(); my_exit(1); } /* * Set up windows */ hw = newwin(LINES, COLS, 0, 0); idlok(stdscr, TRUE); idlok(hw, TRUE); #ifdef MASTER noscore = wizard; #endif new_level(); /* Draw current level */ /* * Start up daemons and fuses */ start_daemon(runners, 0, AFTER); start_daemon(doctor, 0, AFTER); fuse(swander, 0, WANDERTIME, AFTER); start_daemon(stomach, 0, AFTER); playit(); return(0); }
int main(int argc, char **argv) { char c; char *sname = MD_LOCAL_NAME; mddevopts_t options = 0; md_error_t status = mdnullerror; md_error_t *ep = &status; mdsetname_t *sp = NULL; mdsetname_t *local_sp = NULL; char *argname; int todo = 0; int ret = 0; int md_upgd_stat = 0; int error; md_set_desc *sd; /* * Get the locale set up before calling any other routines * with messages to ouput. Just in case we're not in a build * environment, make sure that TEXT_DOMAIN gets set to * something. */ #if !defined(TEXT_DOMAIN) #define TEXT_DOMAIN "SYS_TEST" #endif (void) setlocale(LC_ALL, ""); (void) textdomain(TEXT_DOMAIN); if ((sdssc_bind_library() == SDSSC_OKAY) && (sdssc_cmd_proxy(argc, argv, SDSSC_PROXY_PRIMARY, &error) == SDSSC_PROXY_DONE)) exit(error); openlog("metadevadm", LOG_ODELAY, LOG_USER); /* initialize */ if (md_init(argc, argv, 0, 1, ep) != 0 || meta_check_root(ep) != 0) { closelog(); mde_perror(ep, ""); md_exit(sp, 1); } /* parse args */ optind = 1; opterr = 1; while ((c = getopt(argc, argv, "vlhnrs:u:")) != -1) { switch (c) { case 'v': options |= DEV_VERBOSE; break; case 'n': options |= DEV_NOACTION; break; case 'r': options |= DEV_RELOAD; todo = 1; break; case 's': sname = optarg; break; case 'u': todo = 1; options |= DEV_UPDATE; argname = optarg; if (argname == NULL) { usage("metadevadm"); closelog(); md_exit(sp, 0); } break; case 'l': options |= DEV_LOG; break; case 'h': default: usage("metadevadm"); closelog(); md_exit(sp, 0); } } if ((sp = metasetname(sname, ep)) == NULL) { mde_perror(ep, ""); closelog(); md_exit(sp, 1); } if (!metaislocalset(sp)) { if ((sd = metaget_setdesc(sp, ep)) == NULL) { mde_perror(ep, ""); closelog(); md_exit(sp, 1); } if (MD_MNSET_DESC(sd)) { (void) printf("%s\n", gettext("metadevadm cannot be " "run on multi-owner disksets\n")); closelog(); md_exit(sp, 0); } } if ((options & DEV_VERBOSE) && (todo != 1)) { usage("metadevadm"); closelog(); md_exit(sp, 0); } if ((options & DEV_NOACTION) && (todo != 1)) { usage("metadevadm"); closelog(); md_exit(sp, 0); } if (todo == 0) { usage("metadevadm"); closelog(); md_exit(sp, 0); } if ((local_sp = metasetname(MD_LOCAL_NAME, ep)) == NULL) { mde_perror(ep, ""); closelog(); md_exit(local_sp, 1); } /* lock the local set */ if (meta_lock(local_sp, TRUE, ep) != 0) { mde_perror(ep, ""); closelog(); md_exit(local_sp, 1); } /* grab set lock */ if (meta_lock(sp, TRUE, ep)) { mde_perror(ep, ""); closelog(); md_exit(local_sp, 1); } /* check for ownership */ if (meta_check_ownership(sp, ep) != 0) { /* * If the set is not owned by this node then only update the * local set's replica. */ options |= DEV_LOCAL_SET; } /* * check for upgrade. If upgrade in progress then just exit. */ if (metaioctl(MD_UPGRADE_STAT, &md_upgd_stat, ep, NULL) != 0) { mde_perror(ep, ""); closelog(); (void) meta_unlock(sp, ep); md_exit(local_sp, 1); } if (md_upgd_stat == 0) { ret = meta_fixdevid(sp, options, argname, ep); if (ret == METADEVADM_ERR) { /* * If the call failed, for a DEV_RELOAD still need to * update the .conf file to provide the latest devid * information so exit later. */ if (options & DEV_UPDATE) { closelog(); (void) meta_unlock(sp, ep); md_exit(local_sp, 1); } } } /* * Sync replica list in kernel to replica list in conf files. * This will update driver name and minor number in conf file * if reload was run. Will update device id in conf file if * update was run. */ meta_sync_db_locations(sp, ep); closelog(); (void) meta_unlock(sp, ep); md_exit(local_sp, ret); return (0); }
int main( int argc, char *argv[] ) { int ret, i; const md_info_t *md_info; md_context_t md_ctx; md_init( &md_ctx ); if( argc == 1 ) { const int *list; printf( "print mode: generic_sum <md> <file> <file> ...\n" ); printf( "check mode: generic_sum <md> -c <checksum file>\n" ); printf( "\nAvailable message digests:\n" ); list = md_list(); while( *list ) { md_info = md_info_from_type( *list ); printf( " %s\n", md_info->name ); list++; } #if defined(_WIN32) printf( "\n Press Enter to exit this program.\n" ); fflush( stdout ); getchar(); #endif return( 1 ); } /* * Read the MD from the command line */ md_info = md_info_from_string( argv[1] ); if( md_info == NULL ) { fprintf( stderr, "Message Digest '%s' not found\n", argv[1] ); return( 1 ); } if( md_init_ctx( &md_ctx, md_info) ) { fprintf( stderr, "Failed to initialize context.\n" ); return( 1 ); } ret = 0; if( argc == 4 && strcmp( "-c", argv[2] ) == 0 ) { ret |= generic_check( md_info, argv[3] ); goto exit; } for( i = 2; i < argc; i++ ) ret |= generic_print( md_info, argv[i] ); exit: md_free( &md_ctx ); return( ret ); }