/* @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);
}
