/* @builtin-bind { 'Q', builtin_long_command }, */ int builtin_long_command(interpreter* interp) { unsigned begin, end; string commandName; long_command* curr; int result; /* Extract the long name */ begin = ++interp->ip; while (interp->ip < interp->code->len && !isspace(string_data(interp->code)[interp->ip])) ++interp->ip; end = interp->ip; if (begin == end || begin+1 == end) { print_error("Long command name expected"); return 0; } commandName = create_string(string_data(interp->code)+begin, string_data(interp->code)+end); /* Find the first long command name which matches. */ curr = interp->long_commands; while (curr && !string_equals(curr->name, commandName)) curr = curr->next; /* Don't need the command name anymore. */ free(commandName); if (!curr) { print_error("Long command not found"); return 0; } /* Execute, clean up, and return */ if (curr->cmd.is_native) result = curr->cmd.cmd.native(interp); else result = exec_code(interp, curr->cmd.cmd.user); return result; }
/* For use by abbrev_match(): Match SYMBOL's name against buffer text before point, case-insensitively. When found, return non-zero, so that map_obarray terminates mapping. */ static int abbrev_match_mapper(Lisp_Object symbol, void *arg) { struct abbrev_match_mapper_closure *closure = (struct abbrev_match_mapper_closure *)arg; Charcount abbrev_length; Lisp_Symbol *sym = XSYMBOL(symbol); Lisp_String *abbrev; /* symbol_value should be OK here, because abbrevs are not expected to contain any SYMBOL_MAGIC stuff. */ if (UNBOUNDP(symbol_value(sym)) || NILP(symbol_value(sym))) { /* The symbol value of nil means that abbrev got undefined. */ return 0; } abbrev = symbol_name(sym); abbrev_length = string_char_length(abbrev); if (abbrev_length > closure->maxlen) { /* This abbrev is too large -- it wouldn't fit. */ return 0; } /* If `bar' is an abbrev, and a user presses `fubar<SPC>', we don't normally want to expand it. OTOH, if the abbrev begins with non-word syntax (e.g. `#if'), it is OK to abbreviate it anywhere. */ if (abbrev_length < closure->maxlen && abbrev_length > 0 && (WORD_SYNTAX_P(closure->chartab, string_char(abbrev, 0))) && (WORD_SYNTAX_P(closure->chartab, BUF_FETCH_CHAR(closure->buf, closure->point - (abbrev_length + 1))))) { return 0; } /* Match abbreviation string against buffer text. */ { Bufbyte *ptr = string_data(abbrev); Charcount idx; for (idx = 0; idx < abbrev_length; idx++) { if (DOWNCASE(closure->buf, BUF_FETCH_CHAR(closure->buf, closure->point - abbrev_length + idx)) != DOWNCASE(closure->buf, charptr_emchar(ptr))) { break; } INC_CHARPTR(ptr); } if (idx == abbrev_length) { /* This is the one. */ closure->found = sym; return 1; } } return 0; }
static void print_database (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) { char buf[64]; Lisp_Database *db = XDATABASE (obj); if (print_readably) error ("printing unreadable object #<database 0x%x>", db->header.uid); write_c_string ("#<database \"", printcharfun); print_internal (db->fname, printcharfun, 0); sprintf (buf, "\" (%s/%s/%s) 0x%x>", (char *) string_data (XSYMBOL (db->funcs->get_type (db))->name), (char *) string_data (XSYMBOL (db->funcs->get_subtype (db))->name), (!DATABASE_LIVE_P (db) ? "closed" : (db->access_ & O_WRONLY) ? "writeonly" : (db->access_ & O_RDWR) ? "readwrite" : "readonly"), db->header.uid); write_c_string (buf, printcharfun); }
int string_copy(string *s, char *data, size_t len, size_t pos, size_t *size) { size_t l = string_length(s); if (pos > l) return -1; *size = l - pos < len ? l - pos : len; memcpy(data, string_data(s), *size); return 0; }
string *string_substr(string *s, size_t pos, size_t len) { string *result; size_t n, l = string_length(s); if (pos > l) return NULL; result = malloc(sizeof *result); if (!result) return NULL; n = l - pos < len ? l - pos : len; buffer_init(&result->buffer); buffer_reserve(&result->buffer, n + 1); buffer_insert(&result->buffer, 0, string_data(s) + pos, n); string_data(result)[n] = 0; return result; }
void ensure_file_size(rollingfile_t* rf) { string_buffer_t bak1; string_buffer_t bak2; size_t n; if(rf->current_size < rf->max_size) { if(0 == rf->out) { rf->out = fopen(rf->nm, "a+"); if(0 == rf->out) printf("打开日志文件 '%s' 失败 - %s", rf->nm, strerror(errno)); } return; } if(0 != rf->out) { fclose(rf->out); rf->out = 0; } string_buffer_init(&bak1); string_buffer_init(&bak2); string_buffer_assign(&bak2, rf->nm); string_buffer_append_sprintf(&bak2,".%u", rf->remain_count); remove(string_data(&bak2)); for(n = rf->remain_count-1; n > 0; --n) { string_buffer_assign(&bak1, rf->nm); string_buffer_append_sprintf(&bak1,".%u", n); if(0 != rename(string_data(&bak1), string_data(&bak2))) debugPrintf(string_data(&bak1), string_data(&bak2)); string_buffer_swap(&bak1, &bak2); } if(0 != rename(rf->nm, string_data(&bak2))) { debugPrintf(rf->nm, string_data(&bak2)); } else { rf->current_size = 0; rf->out = fopen(rf->nm, "a+"); if(0 == rf->out) printf("打开日志文件 '%s' 失败 - %s", rf->nm, strerror(errno)); } string_buffer_destroy(&bak1); string_buffer_destroy(&bak2); }
// static bool LLDispatcher::unpackMessage( LLMessageSystem* msg, LLDispatcher::key_t& method, LLUUID& invoice, LLDispatcher::sparam_t& parameters) { char buf[MAX_STRING]; /*Flawfinder: ignore*/ msg->getStringFast(_PREHASH_MethodData, _PREHASH_Method, method); msg->getUUIDFast(_PREHASH_MethodData, _PREHASH_Invoice, invoice); S32 size; S32 count = msg->getNumberOfBlocksFast(_PREHASH_ParamList); for (S32 i = 0; i < count; ++i) { // we treat the SParam as binary data (since it might be an // LLUUID in compressed form which may have embedded \0's,) size = msg->getSizeFast(_PREHASH_ParamList, i, _PREHASH_Parameter); if (size >= 0) { msg->getBinaryDataFast( _PREHASH_ParamList, _PREHASH_Parameter, buf, size, i, MAX_STRING-1); // If the last byte of the data is 0x0, this is either a normally // packed string, or a binary packed UUID (which for these messages // are packed with a 17th byte 0x0). Unpack into a std::string // without the trailing \0, so "abc\0" becomes std::string("abc", 3) // which matches const char* "abc". if (size > 0 && buf[size-1] == 0x0) { // special char*/size constructor because UUIDs may have embedded // 0x0 bytes. std::string binary_data(buf, size-1); parameters.push_back(binary_data); } else { // This is either a NULL string, or a string that was packed // incorrectly as binary data, without the usual trailing '\0'. std::string string_data(buf, size); parameters.push_back(string_data); } } } return true; }
ssh_public_key publickey_from_string(ssh_session session, ssh_string pubkey_s) { ssh_buffer tmpbuf = NULL; ssh_string type_s = NULL; char *type_c = NULL; int type; tmpbuf = buffer_new(); if (tmpbuf == NULL) { return NULL; } if (buffer_add_data(tmpbuf, string_data(pubkey_s), string_len(pubkey_s)) < 0) { goto error; } type_s = buffer_get_ssh_string(tmpbuf); if (type_s == NULL) { ssh_set_error(session,SSH_FATAL,"Invalid public key format"); goto error; } type_c = string_to_char(type_s); string_free(type_s); if (type_c == NULL) { goto error; } type = ssh_type_from_name(type_c); SAFE_FREE(type_c); switch (type) { case TYPE_DSS: return publickey_make_dss(session, tmpbuf); case TYPE_RSA: case TYPE_RSA1: return publickey_make_rsa(session, tmpbuf, type); } ssh_set_error(session, SSH_FATAL, "Unknown public key protocol %s", ssh_type_to_char(type)); error: buffer_free(tmpbuf); return NULL; }
void dylan_format (STREAM stream, D dylan_string, D dylan_arguments) { BOOL percent_p = FALSE; char* string = string_data(dylan_string); D* arguments = vector_data(dylan_arguments); int argument_count = vector_size(dylan_arguments), argument_index = 0, size = (int)strlen(string), i; for (i = 0; i < size; i++) { char c = string[i]; if (percent_p) { char cc = (char)toupper(c); switch (cc) { case 'S': case 'C': if (argument_index < argument_count) print_object(stream, arguments[argument_index++], FALSE, 0); else put_string("**MISSING**", stream); break; case '=': if (argument_index < argument_count) print_object(stream, arguments[argument_index++], TRUE, 0); else put_string("**MISSING**", stream); break; case 'D': case 'X': case 'O': case 'B': if (argument_index < argument_count) print_object(stream, arguments[argument_index++], (BOOL)cc, 0); else put_string("**MISSING**", stream); break; case '%': put_char('%', stream); break; default: ; } percent_p = FALSE; } else if (c == '%') percent_p = TRUE; else put_char(c, stream); } }
/* Single stepping. Takes a fixnum argument which is the constant vector * index at which to find a string. G_REG0 must be valid. */ void C_singlestep( word cidx ) { char buf[ 300 ]; int l; word s; word constvec; in_noninterruptible_syscall = 1; constvec = *( ptrof( globals[G_REG0] ) + 2 ); s = *( ptrof( constvec ) + VEC_HEADER_WORDS + nativeint(cidx) ); if (tagof( s ) != BVEC_TAG) panic_exit( "Internal: Bad arg to C_singlestep().\n" ); l = string_length( s ); strncpy( buf, string_data( s ), min( l, sizeof( buf )-1 ) ); buf[ l ] = 0; hardconsolemsg( "Step: %s", buf ); localdebugger(); in_noninterruptible_syscall = 0; }
DLL_VARIABLE void object_format(object_t* obj, format_fn_t cb, void* ctxt) { switch(obj->o_type) { case object_type_string: { cstring_t str = object_to_string(obj, "", 0); (*cb)( "\"", 1, ctxt); (*cb)(string_data(&str), string_length(&str), ctxt); (*cb)( "\"", 1, ctxt); break; } case object_type_table: { size_t idx; (*cb)(" { ", 3, ctxt); for( idx = 0; idx < object_length(obj); ++ idx) { if(0 != idx) (*cb)(" , ", 3, ctxt); object_format(object_element_at(obj, idx), cb, ctxt); } (*cb)(" } ", 3, ctxt); break; } case object_type_array: { size_t idx; (*cb)(" [ ", 3, ctxt); for( idx = 0; idx < object_length(obj); ++ idx) { if(0 != idx) (*cb)(" , ", 3, ctxt); object_format(object_element_at(obj, idx), cb, ctxt); } (*cb)(" ] ", 3, ctxt); break; } default: { cstring_t s = object_to_string(obj, NULL, 0); (*cb)(s.str, s.len, ctxt); } } }
static int channel_rcv_data1(ssh_session session, int is_stderr) { ssh_channel channel = session->channels; ssh_string str = NULL; str = buffer_get_ssh_string(session->in_buffer); if (str == NULL) { ssh_log(session, SSH_LOG_FUNCTIONS, "Invalid data packet !\n"); return -1; } ssh_log(session, SSH_LOG_RARE, "Adding %zu bytes data in %d", string_len(str), is_stderr); if (channel_default_bufferize(channel, string_data(str), string_len(str), is_stderr) < 0) { string_free(str); return -1; } string_free(str); return 0; }
int master_main(Master* M) { ExceptionScope exScope; int volatile ret = 0; int ex; exception_begin_try(B(M), &exScope); switch ((ex = exception_try(B(M)))) { case Try: master_init(M); master_start_log_writer(M); master_start_login(M); master_start_char_select(M); // Start the IPC thread now to avoid needing to hold the lock while the above processes start master_start_ipc_thread(M); master_main_loop(M); break; case Finally: master_deinit(M); break; default: printf(TERM_RED "[master_main] Unhandled exception (%i): %s\n" TERM_DEFAULT, ex, string_data(exception_get_message(B(M)))); exception_handled(B(M)); ret = ex; break; } exception_end_try_with_finally(B(M)); return ret; }
TEST(json, simple) { object_t* ar; object_t* ar2; object_t* map; object_t* map2; object_t* ret = json_parse_from_string(simpleJson, sizeof(simpleJson)); ASSERT_EQ( true, object_is_type(ret, object_type_array)); ASSERT_EQ( 8, object_length(ret)); ASSERT_EQ( true, object_is_type(object_element_at(ret, 0), object_type_number)); ASSERT_EQ( 12, object_to_int(object_element_at(ret, 0), 0)); ASSERT_EQ( true, object_is_type(object_element_at(ret, 1), object_type_number)); ASSERT_EQ( -23, object_to_int(object_element_at(ret, 1), 0)); ASSERT_EQ( true, object_is_type(object_element_at(ret, 2), object_type_string)); ASSERT_STREQ( "123", string_data(&object_to_string(object_element_at(ret, 2), 0, 0))); ASSERT_EQ( true, object_is_type(object_element_at(ret, 3), object_type_boolean)); ASSERT_EQ( true, object_to_boolean(object_element_at(ret, 3), false)); ASSERT_EQ( true, object_is_type(object_element_at(ret, 4), object_type_boolean)); ASSERT_EQ( false, object_to_boolean(object_element_at(ret, 4), true)); ar = object_element_at(ret, 5); ASSERT_EQ( true, object_is_type(ar, object_type_array)); ASSERT_EQ( 6, object_length(ar)); ASSERT_EQ( true, object_is_type(object_element_at(ar, 0), object_type_number)); ASSERT_EQ( 12, object_to_int(object_element_at(ar, 0), 0)); ASSERT_EQ( true, object_is_type(object_element_at(ar, 1), object_type_number)); ASSERT_EQ( -23, object_to_int(object_element_at(ar, 1), 0)); ASSERT_EQ( true, object_is_type(object_element_at(ar, 2), object_type_string)); ASSERT_STREQ( "123", string_data(&object_to_string(object_element_at(ar, 2), 0, 0))); ASSERT_EQ( true, object_is_type(object_element_at(ar, 3), object_type_boolean)); ASSERT_EQ( true, object_to_boolean(object_element_at(ar, 3), false)); ASSERT_EQ( true, object_is_type(object_element_at(ar, 4), object_type_boolean)); ASSERT_EQ( false, object_to_boolean(object_element_at(ar, 4), true)); map = object_element_at(ar, 5); ASSERT_EQ( true, object_is_type(map, object_type_table)); ASSERT_EQ( true, object_is_type(object_get_object(map, "a"), object_type_string)); ASSERT_STREQ( "b", string_data(&object_to_string(object_get_object(map, "a"),0,0))); map2 = object_element_at(ret, 6); ASSERT_EQ( true, object_is_type(map2, object_type_table)); ASSERT_EQ( true, object_is_type(object_get_object(map2, "a1"), object_type_number)); ASSERT_EQ( 1, object_to_int(object_get_object(map2, "a1"), 0)); ASSERT_EQ( true, object_is_type(object_get_object(map2, "a2"), object_type_number)); ASSERT_EQ( -2, object_to_int(object_get_object(map2, "a2"), 0)); ASSERT_EQ( true, object_is_type(object_get_object(map2, "a3"), object_type_boolean)); ASSERT_EQ( true, object_to_boolean(object_get_object(map2, "a3"), false)); ASSERT_EQ( true, object_is_type(object_get_object(map2, "a4"), object_type_boolean)); ASSERT_EQ( false, object_to_boolean(object_get_object(map2, "a4"), true)); ASSERT_EQ( true, object_is_type(object_get_object(map2, "a5"), object_type_string)); ASSERT_STREQ( "str",string_data(&object_to_string(object_get_object(map2, "a5"),0,0))); ASSERT_EQ( true, object_is_type(object_get_object(map2, "a11"), object_type_number)); ASSERT_EQ( 12, object_to_int(object_get_object(map2, "a11"), 0)); ASSERT_EQ( true, object_is_type(object_get_object(map2, "a6"), object_type_array)); ar2 = object_get_object(map2, "a6"); ASSERT_EQ( true, object_is_type(ar2, object_type_array)); ASSERT_EQ( 6, object_length(ar2)); ASSERT_EQ( true, object_is_type(object_element_at(ar2, 0), object_type_number)); ASSERT_EQ( 12, object_to_int(object_element_at(ar2, 0), 0)); ASSERT_EQ( true, object_is_type(object_element_at(ar2, 1), object_type_number)); ASSERT_EQ( -23, object_to_int(object_element_at(ar2, 1), 0)); ASSERT_EQ( true, object_is_type(object_element_at(ar2, 2), object_type_string)); ASSERT_STREQ( "123", string_data(&object_to_string(object_element_at(ar2, 2),0,0))); ASSERT_EQ( true, object_is_type(object_element_at(ar2, 3), object_type_boolean)); ASSERT_EQ( true, object_to_boolean(object_element_at(ar2, 3), false)); ASSERT_EQ( true, object_is_type(object_element_at(ar2, 4), object_type_boolean)); ASSERT_EQ( false, object_to_boolean(object_element_at(ar2, 4), true)); map2 = object_element_at(ar2, 5); ASSERT_EQ( true, object_is_type(map2, object_type_table)); ASSERT_EQ( true, object_is_type(object_get_object(map, "a"), object_type_string)); ASSERT_STREQ( "b", string_data(&object_to_string(object_get_object(map, "a"),0,0))); }
/* TODO : split this function in two so it becomes smaller */ SIGNATURE *signature_from_string(ssh_session session, ssh_string signature, ssh_public_key pubkey, int needed_type) { SIGNATURE *sign = NULL; ssh_buffer tmpbuf = NULL; ssh_string rs = NULL; ssh_string type_s = NULL; ssh_string e = NULL; char *type_c = NULL; int type; int len; int rsalen; #ifdef HAVE_LIBGCRYPT gcry_sexp_t sig; #elif defined HAVE_LIBCRYPTO DSA_SIG *sig = NULL; ssh_string r = NULL; ssh_string s = NULL; #endif sign = malloc(sizeof(SIGNATURE)); if (sign == NULL) { ssh_set_error(session, SSH_FATAL, "Not enough space"); return NULL; } tmpbuf = buffer_new(); if (tmpbuf == NULL) { ssh_set_error(session, SSH_FATAL, "Not enough space"); signature_free(sign); return NULL; } if (buffer_add_data(tmpbuf, string_data(signature), string_len(signature)) < 0) { signature_free(sign); buffer_free(tmpbuf); return NULL; } type_s = buffer_get_ssh_string(tmpbuf); if (type_s == NULL) { ssh_set_error(session, SSH_FATAL, "Invalid signature packet"); signature_free(sign); buffer_free(tmpbuf); return NULL; } type_c = string_to_char(type_s); string_free(type_s); if (type_c == NULL) { signature_free(sign); buffer_free(tmpbuf); return NULL; } type = ssh_type_from_name(type_c); SAFE_FREE(type_c); if (needed_type != type) { ssh_set_error(session, SSH_FATAL, "Invalid signature type: %s", ssh_type_to_char(type)); signature_free(sign); buffer_free(tmpbuf); return NULL; } switch(needed_type) { case TYPE_DSS: rs = buffer_get_ssh_string(tmpbuf); buffer_free(tmpbuf); /* 40 is the dual signature blob len. */ if (rs == NULL || string_len(rs) != 40) { string_free(rs); signature_free(sign); return NULL; } /* we make use of strings (because we have all-made functions to convert * them to bignums (ou pas ;) */ #ifdef HAVE_LIBGCRYPT if (gcry_sexp_build(&sig, NULL, "(sig-val(dsa(r %b)(s %b)))", 20 ,string_data(rs), 20,(unsigned char *)string_data(rs) + 20)) { string_free(rs); signature_free(sign); return NULL; } #elif defined HAVE_LIBCRYPTO r = string_new(20); s = string_new(20); if (r == NULL || s == NULL) { string_free(r); string_free(s); string_free(rs); signature_free(sign); return NULL; } string_fill(r, string_data(rs), 20); string_fill(s, (char *)string_data(rs) + 20, 20); sig = DSA_SIG_new(); if (sig == NULL) { string_free(r); string_free(s); string_free(rs); signature_free(sign); return NULL; } sig->r = make_string_bn(r); /* is that really portable ? Openssh's hack isn't better */ sig->s = make_string_bn(s); string_free(r); string_free(s); if (sig->r == NULL || sig->s == NULL) { string_free(rs); DSA_SIG_free(sig); signature_free(sign); return NULL; } #endif #ifdef DEBUG_CRYPTO ssh_print_hexa("r", string_data(rs), 20); ssh_print_hexa("s", (const unsigned char *)string_data(rs) + 20, 20); #endif string_free(rs); sign->type = TYPE_DSS; sign->dsa_sign = sig; return sign; case TYPE_RSA: e = buffer_get_ssh_string(tmpbuf); buffer_free(tmpbuf); if (e == NULL) { signature_free(sign); return NULL; } len = string_len(e); #ifdef HAVE_LIBGCRYPT rsalen = (gcry_pk_get_nbits(pubkey->rsa_pub) + 7) / 8; #elif defined HAVE_LIBCRYPTO rsalen = RSA_size(pubkey->rsa_pub); #endif if (len > rsalen) { string_free(e); signature_free(sign); ssh_set_error(session, SSH_FATAL, "Signature too big! %d instead of %d", len, rsalen); return NULL; } if (len < rsalen) { ssh_log(session, SSH_LOG_RARE, "RSA signature len %d < %d", len, rsalen); } sign->type = TYPE_RSA; #ifdef HAVE_LIBGCRYPT if (gcry_sexp_build(&sig, NULL, "(sig-val(rsa(s %b)))", string_len(e), string_data(e))) { signature_free(sign); string_free(e); return NULL; } sign->rsa_sign = sig; #elif defined HAVE_LIBCRYPTO sign->rsa_sign = e; #endif #ifdef DEBUG_CRYPTO ssh_log(session, SSH_LOG_FUNCTIONS, "len e: %d", len); ssh_print_hexa("RSA signature", string_data(e), len); #endif #ifdef HAVE_LIBGCRYPT string_free(e); #endif return sign; default: return NULL; } return NULL; }
void print_string_data (STREAM stream, D instance, BOOL escape_p, int print_depth) { ignore(escape_p); ignore(print_depth); format(stream, "%s", string_data(instance)); }
ssh_public_key publickey_make_rsa(ssh_session session, ssh_buffer buffer, int type) { ssh_string e = NULL; ssh_string n = NULL; ssh_public_key key = NULL; key = malloc(sizeof(struct ssh_public_key_struct)); if (key == NULL) { buffer_free(buffer); return NULL; } key->type = type; key->type_c = ssh_type_to_char(key->type); e = buffer_get_ssh_string(buffer); n = buffer_get_ssh_string(buffer); buffer_free(buffer); /* we don't need it anymore */ if(e == NULL || n == NULL) { ssh_set_error(session, SSH_FATAL, "Invalid RSA public key"); goto error; } #ifdef HAVE_LIBGCRYPT gcry_sexp_build(&key->rsa_pub, NULL, "(public-key(rsa(n %b)(e %b)))", string_len(n), string_data(n), string_len(e),string_data(e)); if (key->rsa_pub == NULL) { goto error; } #elif HAVE_LIBCRYPTO key->rsa_pub = RSA_new(); if (key->rsa_pub == NULL) { goto error; } key->rsa_pub->e = make_string_bn(e); key->rsa_pub->n = make_string_bn(n); if (key->rsa_pub->e == NULL || key->rsa_pub->n == NULL) { goto error; } #endif #ifdef DEBUG_CRYPTO ssh_print_hexa("e", string_data(e), string_len(e)); ssh_print_hexa("n", string_data(n), string_len(n)); #endif string_burn(e); string_free(e); string_burn(n); string_free(n); return key; error: string_burn(e); string_free(e); string_burn(n); string_free(n); publickey_free(key); return NULL; }
ssh_string ssh_encrypt_rsa1(ssh_session session, ssh_string data, ssh_public_key key) { ssh_string str = NULL; size_t len = string_len(data); size_t size = 0; #ifdef HAVE_LIBGCRYPT const char *tmp = NULL; gcry_sexp_t ret_sexp; gcry_sexp_t data_sexp; if (gcry_sexp_build(&data_sexp, NULL, "(data(flags pkcs1)(value %b))", len, string_data(data))) { ssh_set_error(session, SSH_FATAL, "RSA1 encrypt: libgcrypt error"); return NULL; } if (gcry_pk_encrypt(&ret_sexp, data_sexp, key->rsa_pub)) { gcry_sexp_release(data_sexp); ssh_set_error(session, SSH_FATAL, "RSA1 encrypt: libgcrypt error"); return NULL; } gcry_sexp_release(data_sexp); data_sexp = gcry_sexp_find_token(ret_sexp, "a", 0); if (data_sexp == NULL) { ssh_set_error(session, SSH_FATAL, "RSA1 encrypt: libgcrypt error"); gcry_sexp_release(ret_sexp); return NULL; } tmp = gcry_sexp_nth_data(data_sexp, 1, &size); if (*tmp == 0) { size--; tmp++; } str = string_new(size); if (str == NULL) { ssh_set_error(session, SSH_FATAL, "Not enough space"); gcry_sexp_release(data_sexp); gcry_sexp_release(ret_sexp); return NULL; } string_fill(str, tmp, size); gcry_sexp_release(data_sexp); gcry_sexp_release(ret_sexp); #elif defined HAVE_LIBCRYPTO size = RSA_size(key->rsa_pub); str = string_new(size); if (str == NULL) { ssh_set_error(session, SSH_FATAL, "Not enough space"); return NULL; } if (RSA_public_encrypt(len, string_data(data), string_data(str), key->rsa_pub, RSA_PKCS1_PADDING) < 0) { string_free(str); return NULL; } #endif return str; }
/* @builtin-bind { '"', builtin_string }, */ int builtin_string(interpreter* interp) { string accum, s; int result; unsigned begin; accum = empty_string(); ++interp->ip; while (1) { /* Scan for the next important character. */ for (begin = interp->ip; is_ip_valid(interp); ++interp->ip) if (curr(interp) == '"' || curr(interp) == '$' || curr(interp) == '`' || curr(interp) == '\\' || curr(interp) == '%') break; /* Found important character or EOI. */ if (!is_ip_valid(interp)) { print_error("Encountered end-of-input in string literal"); goto error; } /* Append everything in-between */ accum = append_data(accum, string_data(interp->code) + begin, string_data(interp->code) + interp->ip); switch (curr(interp)) { case '"': goto done; case '$': ++interp->ip; if (!is_ip_valid(interp)) { print_error("Encountered end-of-input in string literal"); goto error; } /* Append value of this register */ accum = append_string(accum, interp->registers[curr(interp)]); touch_reg(interp, curr(interp)); break; case '%': s = stack_pop(interp); if (!s) { print_error("Stack underflow"); goto error; } accum = append_string(accum, s); free(s); break; case '`': if (!interp->initial_whitespace) { print_error("Initial whitespace (`) not available in this context."); goto error; } accum = append_string(accum, interp->initial_whitespace); break; case '\\': result = builtin_escape(interp); if (!result) goto error; if (result == 2) break; /* Didn't push anything */ s = stack_pop(interp); /* Popping will always succeed if escape returned success. */ accum = append_string(accum, s); free(s); break; } /* All the above (which don't goto elsewhere) leave the IP on the end of * whatever special thing they did. */ ++interp->ip; } done: stack_push(interp, accum); return 1; error: diagnostic(interp, NULL); free(accum); return 0; }
/** \brief Makes a PUBLIC_KEY object out of a PRIVATE_KEY object * \param prv the Private key * \returns the public key * \see publickey_to_string() */ ssh_public_key publickey_from_privatekey(ssh_private_key prv) { ssh_public_key key = NULL; #ifdef HAVE_LIBGCRYPT gcry_sexp_t sexp; const char *tmp = NULL; size_t size; ssh_string p = NULL; ssh_string q = NULL; ssh_string g = NULL; ssh_string y = NULL; ssh_string e = NULL; ssh_string n = NULL; #endif /* HAVE_LIBGCRYPT */ key = malloc(sizeof(struct ssh_public_key_struct)); if (key == NULL) { return NULL; } key->type = prv->type; switch(key->type) { case TYPE_DSS: #ifdef HAVE_LIBGCRYPT sexp = gcry_sexp_find_token(prv->dsa_priv, "p", 0); if (sexp == NULL) { goto error; } tmp = gcry_sexp_nth_data(sexp, 1, &size); p = string_new(size); if (p == NULL) { goto error; } string_fill(p,(char *) tmp, size); gcry_sexp_release(sexp); sexp = gcry_sexp_find_token(prv->dsa_priv,"q",0); if (sexp == NULL) { goto error; } tmp = gcry_sexp_nth_data(sexp,1,&size); q = string_new(size); if (q == NULL) { goto error; } string_fill(q,(char *) tmp,size); gcry_sexp_release(sexp); sexp = gcry_sexp_find_token(prv->dsa_priv, "g", 0); if (sexp == NULL) { goto error; } tmp = gcry_sexp_nth_data(sexp,1,&size); g = string_new(size); if (g == NULL) { goto error; } string_fill(g,(char *) tmp,size); gcry_sexp_release(sexp); sexp = gcry_sexp_find_token(prv->dsa_priv,"y",0); if (sexp == NULL) { goto error; } tmp = gcry_sexp_nth_data(sexp,1,&size); y = string_new(size); if (y == NULL) { goto error; } string_fill(y,(char *) tmp,size); gcry_sexp_release(sexp); gcry_sexp_build(&key->dsa_pub, NULL, "(public-key(dsa(p %b)(q %b)(g %b)(y %b)))", string_len(p), string_data(p), string_len(q), string_data(q), string_len(g), string_data(g), string_len(y), string_data(y)); string_burn(p); string_free(p); string_burn(q); string_free(q); string_burn(g); string_free(g); string_burn(y); string_free(y); #elif defined HAVE_LIBCRYPTO key->dsa_pub = DSA_new(); if (key->dsa_pub == NULL) { goto error; } key->dsa_pub->p = BN_dup(prv->dsa_priv->p); key->dsa_pub->q = BN_dup(prv->dsa_priv->q); key->dsa_pub->g = BN_dup(prv->dsa_priv->g); key->dsa_pub->pub_key = BN_dup(prv->dsa_priv->pub_key); if (key->dsa_pub->p == NULL || key->dsa_pub->q == NULL || key->dsa_pub->g == NULL || key->dsa_pub->pub_key == NULL) { goto error; } #endif /* HAVE_LIBCRYPTO */ break; case TYPE_RSA: case TYPE_RSA1: #ifdef HAVE_LIBGCRYPT sexp = gcry_sexp_find_token(prv->rsa_priv, "n", 0); if (sexp == NULL) { goto error; } tmp = gcry_sexp_nth_data(sexp, 1, &size); n = string_new(size); if (n == NULL) { goto error; } string_fill(n, (char *) tmp, size); gcry_sexp_release(sexp); sexp = gcry_sexp_find_token(prv->rsa_priv, "e", 0); if (sexp == NULL) { goto error; } tmp = gcry_sexp_nth_data(sexp, 1, &size); e = string_new(size); if (e == NULL) { goto error; } string_fill(e, (char *) tmp, size); gcry_sexp_release(sexp); gcry_sexp_build(&key->rsa_pub, NULL, "(public-key(rsa(n %b)(e %b)))", string_len(n), string_data(n), string_len(e), string_data(e)); if (key->rsa_pub == NULL) { goto error; } string_burn(e); string_free(e); string_burn(n); string_free(n); #elif defined HAVE_LIBCRYPTO key->rsa_pub = RSA_new(); if (key->rsa_pub == NULL) { goto error; } key->rsa_pub->e = BN_dup(prv->rsa_priv->e); key->rsa_pub->n = BN_dup(prv->rsa_priv->n); if (key->rsa_pub->e == NULL || key->rsa_pub->n == NULL) { goto error; } #endif break; } key->type_c = ssh_type_to_char(prv->type); return key; error: #ifdef HAVE_LIBGCRYPT gcry_sexp_release(sexp); string_burn(p); string_free(p); string_burn(q); string_free(q); string_burn(g); string_free(g); string_burn(y); string_free(y); string_burn(e); string_free(e); string_burn(n); string_free(n); #endif publickey_free(key); return NULL; }
/* Common function for v and V. * * aux: if non-NULL, any code to evaluate before the defun * defun: command to run to define the command. */ static int builtin_defunlibrary_common(interpreter* interp, string aux, byte defun) { string name, body, code; struct tm* now; time_t seconds; char header[256], date[64]; FILE* out; unsigned i; if (!stack_pop_strings(interp, 2, &body, &name)) UNDERFLOW; /* We can't allow the name to have parentheses or the NUL character. */ for (i = 0; i < name->len; ++i) if (string_data(name)[i] == '(' || string_data(name)[i] == ')' || string_data(name)[i] == 0) { print_error_s("Invalid command name (for use with v/V)", name); stack_push(interp, name); stack_push(interp, body); return 0; } /* Build code */ time(&seconds); now = localtime(&seconds); strftime(date, sizeof(date)-1, "%A, %Y.%m.%d %H:%M:%S", now); snprintf(header, sizeof(header), "\n(Added by %s on %s);\n", getenv("USER"), date); code = convert_string(header); if (aux) code = append_string(code, aux); code = append_cstr(code, "("); code = append_string(code, name); code = append_cstr(code, ")("); code = append_string(code, body); code = append_cstr(code, ")"); code = append_data(code, &defun, (&defun)+1); code = append_cstr(code, "\n"); /* Evaluate in current */ if (!exec_code(interp, code)) { print_error("not adding function to library due to error(s)"); stack_push(interp, name); stack_push(interp, code); return 0; } /* Don't need name or code anymore. */ free(name); free(body); /* OK, write out */ out = fopen(user_library_file, "a"); if (!out) { fprintf(stderr, "tgl: error: unable to open %s: %s\n", user_library_file, strerror(errno)); free(code); return 0; } if (code->len != fwrite(string_data(code), 1, code->len, out)) { fprintf(stderr, "tgl: error writing to %s: %s\n", user_library_file, strerror(errno)); free(code); fclose(out); return 0; } /* Success */ fclose(out); free(code); return 1; }
/* Signature decoding functions */ static ssh_string signature_to_string(SIGNATURE *sign) { unsigned char buffer[40] = {0}; ssh_buffer tmpbuf = NULL; ssh_string str = NULL; ssh_string tmp = NULL; ssh_string rs = NULL; int rc = -1; #ifdef HAVE_LIBGCRYPT const char *r = NULL; const char *s = NULL; gcry_sexp_t sexp; size_t size = 0; #elif defined HAVE_LIBCRYPTO ssh_string r = NULL; ssh_string s = NULL; #endif tmpbuf = buffer_new(); if (tmpbuf == NULL) { return NULL; } tmp = string_from_char(ssh_type_to_char(sign->type)); if (tmp == NULL) { buffer_free(tmpbuf); return NULL; } if (buffer_add_ssh_string(tmpbuf, tmp) < 0) { buffer_free(tmpbuf); string_free(tmp); return NULL; } string_free(tmp); switch(sign->type) { case TYPE_DSS: #ifdef HAVE_LIBGCRYPT sexp = gcry_sexp_find_token(sign->dsa_sign, "r", 0); if (sexp == NULL) { buffer_free(tmpbuf); return NULL; } r = gcry_sexp_nth_data(sexp, 1, &size); if (*r == 0) { /* libgcrypt put 0 when first bit is set */ size--; r++; } memcpy(buffer, r + size - 20, 20); gcry_sexp_release(sexp); sexp = gcry_sexp_find_token(sign->dsa_sign, "s", 0); if (sexp == NULL) { buffer_free(tmpbuf); return NULL; } s = gcry_sexp_nth_data(sexp,1,&size); if (*s == 0) { size--; s++; } memcpy(buffer+ 20, s + size - 20, 20); gcry_sexp_release(sexp); #elif defined HAVE_LIBCRYPTO r = make_bignum_string(sign->dsa_sign->r); if (r == NULL) { buffer_free(tmpbuf); return NULL; } s = make_bignum_string(sign->dsa_sign->s); if (s == NULL) { buffer_free(tmpbuf); string_free(r); return NULL; } memcpy(buffer, (char *)string_data(r) + string_len(r) - 20, 20); memcpy(buffer + 20, (char *)string_data(s) + string_len(s) - 20, 20); string_free(r); string_free(s); #endif /* HAVE_LIBCRYPTO */ rs = string_new(40); if (rs == NULL) { buffer_free(tmpbuf); return NULL; } string_fill(rs, buffer, 40); rc = buffer_add_ssh_string(tmpbuf, rs); string_free(rs); if (rc < 0) { buffer_free(tmpbuf); return NULL; } break; case TYPE_RSA: case TYPE_RSA1: #ifdef HAVE_LIBGCRYPT sexp = gcry_sexp_find_token(sign->rsa_sign, "s", 0); if (sexp == NULL) { buffer_free(tmpbuf); return NULL; } s = gcry_sexp_nth_data(sexp,1,&size); if (*s == 0) { size--; s++; } rs = string_new(size); if (rs == NULL) { buffer_free(tmpbuf); return NULL; } string_fill(rs, (char *) s, size); rc = buffer_add_ssh_string(tmpbuf, rs); gcry_sexp_release(sexp); string_free(rs); if (rc < 0) { buffer_free(tmpbuf); return NULL; } #elif defined HAVE_LIBCRYPTO if (buffer_add_ssh_string(tmpbuf,sign->rsa_sign) < 0) { buffer_free(tmpbuf); return NULL; } #endif break; } str = string_new(buffer_get_len(tmpbuf)); if (str == NULL) { buffer_free(tmpbuf); return NULL; } string_fill(str, buffer_get(tmpbuf), buffer_get_len(tmpbuf)); buffer_free(tmpbuf); return str; }
ssh_public_key publickey_make_dss(ssh_session session, ssh_buffer buffer) { ssh_string p = NULL; ssh_string q = NULL; ssh_string g = NULL; ssh_string pubkey = NULL; ssh_public_key key = NULL; key = malloc(sizeof(struct ssh_public_key_struct)); if (key == NULL) { buffer_free(buffer); return NULL; } key->type = TYPE_DSS; key->type_c = ssh_type_to_char(key->type); p = buffer_get_ssh_string(buffer); q = buffer_get_ssh_string(buffer); g = buffer_get_ssh_string(buffer); pubkey = buffer_get_ssh_string(buffer); buffer_free(buffer); /* we don't need it anymore */ if (p == NULL || q == NULL || g == NULL || pubkey == NULL) { ssh_set_error(session, SSH_FATAL, "Invalid DSA public key"); goto error; } #ifdef HAVE_LIBGCRYPT gcry_sexp_build(&key->dsa_pub, NULL, "(public-key(dsa(p %b)(q %b)(g %b)(y %b)))", string_len(p), string_data(p), string_len(q), string_data(q), string_len(g), string_data(g), string_len(pubkey), string_data(pubkey)); if (key->dsa_pub == NULL) { goto error; } #elif defined HAVE_LIBCRYPTO key->dsa_pub = DSA_new(); if (key->dsa_pub == NULL) { goto error; } key->dsa_pub->p = make_string_bn(p); key->dsa_pub->q = make_string_bn(q); key->dsa_pub->g = make_string_bn(g); key->dsa_pub->pub_key = make_string_bn(pubkey); if (key->dsa_pub->p == NULL || key->dsa_pub->q == NULL || key->dsa_pub->g == NULL || key->dsa_pub->pub_key == NULL) { goto error; } #endif /* HAVE_LIBCRYPTO */ #ifdef DEBUG_CRYPTO ssh_print_hexa("p", string_data(p), string_len(p)); ssh_print_hexa("q", string_data(q), string_len(q)); ssh_print_hexa("g", string_data(g), string_len(g)); #endif string_burn(p); string_free(p); string_burn(q); string_free(q); string_burn(g); string_free(g); string_burn(pubkey); string_free(pubkey); return key; error: string_burn(p); string_free(p); string_burn(q); string_free(q); string_burn(g); string_free(g); string_burn(pubkey); string_free(pubkey); publickey_free(key); return NULL; }
int string_compare(string *s1, string *s2) { return strcmp(string_data(s1), string_data(s2)); }
void oauth_signandappend_oauth_header(const char *reqMethod, struct url_props *url, const char *consumerKey, const char *consumerSecret, const char *authToken, const char *authTokenSecret, const time_t now, const char *postContent, const size_t postContentLen, const char *oauthCallback, const char *oauthVerifier, const char *oauthScope, struct string *out) { struct signctx senv; char _tb[256]; const size_t _tbLen = sprintf(_tb, "%u", (unsigned)now); struct timeval tv; struct md5_context md5Ctx; signctx_init(&senv); init_signature_seed(&senv, reqMethod, url); if (postContentLen) append_signature_params(&senv, postContent, postContent + postContentLen); string_append(out, "Authorization: OAuth ", 21); append_signature_param(&senv, "oauth_consumer_key", 18, consumerKey, strlen(consumerKey)); string_appendfmt(out, "oauth_consumer_key=\"%s\"", consumerKey); append_signature_param(&senv, "oauth_signature_method", 22, "HMAC-SHA1", 9); string_append(out, ",oauth_signature_method=\"HMAC-SHA1\"", 35); string_appendfmt(out,",oauth_timestamp=\"%u\"", (uint32_t)now); append_signature_param(&senv, "oauth_timestamp", 15, _tb, _tbLen); gettimeofday(&tv, NULL); uint8_t digest[16]; char digestAlpha[33]; md5_init(&md5Ctx); md5_update(&md5Ctx, (uint8_t *)&tv.tv_sec, sizeof(tv.tv_sec)); md5_update(&md5Ctx, (uint8_t *)&tv.tv_usec, sizeof(tv.tv_usec)); md5_update(&md5Ctx, (uint8_t *)consumerKey, strlen(consumerKey)); md5_update(&md5Ctx, (uint8_t *)"io.language", 11); md5_finalize(&md5Ctx, digest); md5_string((char *)digest, digestAlpha); const size_t digestAlphaLen = strlen(digestAlpha); // 32 string_appendfmt(out, ",oauth_nonce=\"%.*s\"", digestAlphaLen, digestAlpha); append_signature_param(&senv, "oauth_nonce", 11, digestAlpha, digestAlphaLen); string_appendfmt(out, ",oauth_version=\"1.0\"", 20); append_signature_param(&senv, "oauth_version", 13, "1.0", 3); if (authToken && *authToken != '\0') { string_appendfmt(out, ",oauth_token=\"%s\"", authToken); append_signature_param(&senv, "oauth_token", 11, authToken, strlen(authToken)); } if (oauthCallback && *oauthCallback != '\0') { string_appendfmt(out, ",oauth_callback=\"%s\"", oauthCallback); append_signature_param(&senv, "oauth_callback", 14, oauthCallback, strlen(oauthCallback)); } if (oauthVerifier && *oauthVerifier != '\0') { string_appendfmt(out, ",oauth_verifier=\"%s\"", oauthVerifier); append_signature_param(&senv, "oauth_verifier", 14, oauthVerifier, strlen(oauthVerifier)); } if (oauthScope && *oauthScope != '\0') { string_appendfmt(out, ",scope=\"%s\"", oauthScope); append_signature_param(&senv, "scope", 5, oauthScope, strlen(oauthScope)); } build_signature(&senv, "HMAC-SHA1", consumerSecret, authTokenSecret ? authTokenSecret : ""); string_append(out, ",oauth_signature=\"", 18); string_append_urlencoded_rfc3986(out, string_data(&senv.signatureParamsBuf), string_len(&senv.signatureParamsBuf)); string_append(out, "\"\r\n", 3); signctx_dealloc(&senv); }