static void print_commands(int desc, char term, const struct cl_engine *engine)
{
unsigned i, n;
const char *engine_ver = cl_retver();
const char *clamd_ver = get_version();
if (strcmp(engine_ver, clamd_ver)) {
mdprintf(desc, "ENGINE VERSION MISMATCH: %s != %s. ERROR%c",
engine_ver, clamd_ver, term);
return;
}
print_ver(desc, '|', engine);
mdprintf(desc, " COMMANDS:");
n = sizeof(commands)/sizeof(commands[0]);
for (i=0;i<n;i++) {
mdprintf(desc, " %s", commands[i].cmd);
}
mdprintf(desc, "%c", term);
}
int global_options(int argc, char **argv)
{
char *s;
/* set program name */
setprogname(argv[0]);
#ifndef NO_PIPED_COMMANDS
/* command for compressing */
s = getenv("LVQSOM_COMPRESS_COMMAND");
if (s)
compress_command = s;
s = extract_parameter(argc, argv, "-compress_cmd", OPTION);
if (s)
compress_command = s;
/* command for uncompressing */
s = getenv("LVQSOM_UNCOMPRESS_COMMAND");
if (s)
uncompress_command = s;
s = extract_parameter(argc, argv, "-uncompress_cmd", OPTION);
if (s)
uncompress_command = s;
#endif /* NO_PIPED_COMMANDS */
/* string that identifies a vector component to be ignored in files */
s = getenv("LVQSOM_MASK_STR");
if (s)
masked_string = s;
s = extract_parameter(argc, argv, "-mask_str", OPTION);
if (s)
masked_string = s;
if (extract_parameter(argc, argv, "-version", OPTION2))
fprintf(stderr, "Version: %s\n", get_version());
verbose(oatoi(extract_parameter(argc, argv, VERBOSE, OPTION), 1));
return 0;
}
/* start daemon service */
void Common::start_service(char *package_name, char *service_name)
{
/* get the sdk version */
int version = get_version();
pid_t pid = fork();
// Logc("get the fork pid:%d",pid);
if (pid < 0)
{
Logc("app exit,pid is:%d",pid);
exit(EXIT_SUCCESS);
}
else if (pid == 0)
{
if (package_name == NULL || service_name == NULL)
{
Logc("package name or service name is null");
return;
}
char *p_name = str_stitching(package_name, "/");
char *s_name = str_stitching(p_name, service_name);
// Logc("service: %s", s_name);
int ret = -1000;
if (version >= 17 || version == 0)
{
execlp("am", "am", "startservice",
"--user", "0", "-n", s_name, (char *) NULL);
Logc("result %d", ret);
}
else
{//startservice
ret = execlp("am", "am", "startservice", "-n", s_name, (char *) NULL);
}
Logc("exit start-service child process ret:%d",ret);
exit(EXIT_SUCCESS);
}
else
{
Logc("waitpid,pid is:%d",pid);
waitpid(pid, NULL, 0);
}
}
json_t * getInfo(const json_t *requestJson) {
json_t *responseJson = NULL;
json_t* result = json_object();
char * response = get_version();
if(response) {
json_object_set_new(result, "machineFirmvareVersion", json_string(response));
} else {
logger(LEVEL_WARN, "get_info() invalid version response");
return server_error(requestJson);
}
json_object_set_new(result, "machineName", json_string("Good Coffee Machine"));
responseJson = jsonrpc_response(requestJson, result, FALSE);
return responseJson;
}
static void help(void)
{
printf("\n");
printf(" Clam AntiVirus: Bytecode Testing Tool %s\n",
get_version());
printf(" By The ClamAV Team: http://www.clamav.net/team\n");
printf(" (C) 2009 Sourcefire, Inc.\n\n");
printf("clambc <file> [function] [param1 ...]\n\n");
printf(" --help -h Show help\n");
printf(" --version -V Show version\n");
printf(" --info -i Print information about bytecode\n");
printf(" --printsrc -p Print bytecode source\n");
printf(" --printbcir -c Print bytecode IR\n");
printf(" --trace <level> Set bytecode trace level 0..7 (default 7)\n");
printf(" --no-trace-showsource Don't show source line during tracing\n");
printf(" file file to test\n");
printf("\n");
return;
}
int run(GList **config)
{
char *version = get_version();
char *title=NULL;
asprintf(&title, _("Welcome to %s"), version);
dialog_vars.backtitle=gen_backtitle(_("Welcome"));
dlg_put_backtitle();
dlg_clear();
dialog_msgbox(title, _("Welcome among the users of Frugalware!\n\n"
"The aim of creating Frugalware was to help you to do your work "
"faster and simpler. We hope that you will like our "
"product.\n\n"
"The Frugalware Developer Team"), 0, 0, 1);
FREE(version);
return(0);
}
/* See AddFunc in funcadd.h */
static void declare_func(const char *name, rfunc f,
int type, int nargs, void *funcinfo, AmplExports *ae) {
const char *attr = "";
UNUSED(f);
UNUSED(type);
UNUSED(nargs);
UNUSED(funcinfo);
UNUSED(ae);
if ((type & FUNCADD_RANDOM_VALUED) != 0)
attr = " random";
else if ((type & FUNCADD_STRING_VALUED) != 0)
attr = " symbolic";
if (strcmp(name, "gsl_version") == 0) {
typedef const char *(*Func)(arglist *al);
Func get_version = (Func)f;
printf("amplgsl %s\n", get_version(NULL));
}
fprintf(out, "function %s%s;\n", name, attr);
}
/* Copies the record version into the headers. The
* version must have 2 bytes at least.
*/
inline static void
copy_record_version(gnutls_session_t session,
gnutls_handshake_description_t htype,
uint8_t version[2])
{
const version_entry_st *lver;
if (session->internals.initial_negotiation_completed
|| htype != GNUTLS_HANDSHAKE_CLIENT_HELLO
|| session->internals.default_record_version[0] == 0) {
lver = get_version(session);
version[0] = lver->major;
version[1] = lver->minor;
} else {
version[0] = session->internals.default_record_version[0];
version[1] = session->internals.default_record_version[1];
}
}
/* start daemon service */
static void start_service(char *package_name, char *service_name)
{
/* get the sdk version */
int version = get_version();
pid_t pid;
if ((pid = fork()) < 0)
{
exit(EXIT_SUCCESS);
}
else if (pid == 0)
{
if (package_name == NULL || service_name == NULL)
{
LOGE(LOG_TAG, "package name or service name is null");
return;
}
char *p_name = str_stitching(package_name, "/");
char *s_name = str_stitching(p_name, service_name);
LOGD(LOG_TAG, "service: %s", s_name);
if (version >= 17 || version == 0)
{
int ret = execlp("am", "am", "startservice",
"--user", "0", "-n", s_name, (char *) NULL);
LOGD(LOG_TAG, "result %d", ret);
}
else
{
execlp("am", "am", "startservice", "-n", s_name, (char *) NULL);
}
LOGD(LOG_TAG , "exit start-service child process");
exit(EXIT_SUCCESS);
}
else
{
waitpid(pid, NULL, 0);
}
}
std::wstring get_version()
{
std::wstring version = L"Not found";
struct co_init
{
co_init(){::CoInitialize(nullptr);}
~co_init(){::CoUninitialize();}
} init;
try
{
CComPtr<IDeckLinkIterator> pDecklinkIterator;
if(SUCCEEDED(pDecklinkIterator.CoCreateInstance(CLSID_CDeckLinkIterator)))
version = get_version(pDecklinkIterator);
}
catch(...){}
return version;
}
int idmef_analyzer_setup(idmef_analyzer_t *analyzer, const char *analyzer_name){
int ret;
prelude_string_t *str;
/* alert->analyzer->name */
ret = idmef_analyzer_new_name(analyzer, &str);
if ( ret < 0 )
return ret;
prelude_string_set_constant(str, analyzer_name);
/* alert->analyzer->model */
ret = idmef_analyzer_new_model(analyzer, &str);
if ( ret < 0 )
return ret;
prelude_string_set_constant(str, ANALYZER_MODEL );
/* alert->analyzer->class */
ret = idmef_analyzer_new_class(analyzer, &str);
if ( ret < 0 )
return ret;
prelude_string_set_constant(str, ANALYZER_CLASS);
/* alert->analyzer->manufacturer */
ret = idmef_analyzer_new_manufacturer(analyzer, &str);
if ( ret < 0 )
return ret;
prelude_string_set_constant(str, ANALYZER_MANUFACTURER);
/* alert->analyzer->version */
ret = idmef_analyzer_new_version(analyzer, &str);
if ( ret < 0 )
return ret;
prelude_string_set_constant(str, get_version());
return 0;
}
static int keepalive_start (CcnetProcessor *processor,
int argc, char **argv)
{
CcnetKeepaliveProcPriv *priv = GET_PRIV (processor);
if (IS_SLAVE(processor)) {
char buf[16];
int v, len;
if (argc == 0) {
priv->used_version = 0;
ccnet_processor_send_response (processor,
SC_VERSION_MISMATCH, SS_VERSION_MISMATCH, NULL, 0);
ccnet_processor_done (processor, FALSE);
return 0;
} else {
v = get_version(argv[0]);
if ((priv->used_version = get_used_version(v)) == -1) {
ccnet_processor_send_response (processor,
SC_VERSION_MISMATCH, SS_VERSION_MISMATCH, NULL, 0);
ccnet_processor_done (processor, FALSE);
return 0;
}
len = snprintf (buf, 16, "v%d", priv->used_version);
ccnet_processor_send_response (processor,
SC_OK, SS_OK, buf, len + 1);
return 0;
}
}
/* master */
g_assert (processor->peer->keepalive_sending == 0);
priv->count = 0;
processor->state = INIT;
processor->peer->keepalive_sending = 1;
send_request (processor);
reset_timeout (processor);
return 0;
}
/* Print some debugging info */
void
SgAsmGenericFormat::dump(FILE *f, const char *prefix, ssize_t idx) const
{
char p[4096];
if (idx>=0) {
snprintf(p, sizeof(p),"%sFormat[%zd].", prefix, idx);
} else {
snprintf(p, sizeof(p),"%sFormat.", prefix);
}
const int w = std::max(1, DUMP_FIELD_WIDTH-(int)strlen(p));
fprintf(f, "%s%-*s = %s\n", p, w, "family", to_string(get_family()).c_str());
fprintf(f, "%s%-*s = %s\n", p, w, "purpose", to_string(get_purpose()).c_str());
fprintf(f, "%s%-*s = %s\n", p, w, "sex", to_string(get_sex()).c_str());
fprintf(f, "%s%-*s = %u (%scurrent)\n", p, w, "version", get_version(), get_is_current_version() ? "" : "not-" );
fprintf(f, "%s%-*s = %s\n", p, w, "ABI", to_string(get_abi()).c_str());
fprintf(f, "%s%-*s = %u\n", p, w, "ABIvers", get_abi_version());
fprintf(f, "%s%-*s = %zu\n", p, w, "wordsize", get_word_size());
}
/* Check if the given signature algorithm is supported.
* This means that it is enabled by the priority functions,
* and in case of a server a matching certificate exists.
*/
int
_gnutls_session_sign_algo_enabled(gnutls_session_t session,
gnutls_sign_algorithm_t sig)
{
unsigned i;
int ret;
const version_entry_st *ver = get_version(session);
sig_ext_st *priv;
extension_priv_data_t epriv;
if (unlikely(ver == NULL))
return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
ret =
_gnutls_ext_get_session_data(session,
GNUTLS_EXTENSION_SIGNATURE_ALGORITHMS,
&epriv);
if (ret < 0) {
gnutls_assert();
return 0;
}
priv = epriv.ptr;
if (!_gnutls_version_has_selectable_sighash(ver)
|| priv->sign_algorithms_size == 0)
/* none set, allow all */
{
return 0;
}
for (i = 0; i < session->internals.priorities.sign_algo.algorithms;
i++) {
if (session->internals.priorities.sign_algo.priority[i] ==
sig) {
return 0; /* ok */
}
}
return GNUTLS_E_UNSUPPORTED_SIGNATURE_ALGORITHM;
}
static void
handle_method_call (GDBusConnection * connection,
const gchar * sender, const gchar * object_path, const gchar * interface_name, const gchar * method_name, GVariant * parameters, GDBusMethodInvocation * invocation, gpointer user_data)
{
g_printf ("Inside Handle Method(%s) Call \n", method_name);
if (g_strcmp0 (method_name, "HelloWorld") == 0)
{
const gchar *greeting;
gchar *response;
g_variant_get (parameters, "(&s)", &greeting);
response = g_strdup_printf ("You typed '%s', !!! ", greeting);
g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", response));
//g_print ("Sending %s -> to the client ", response);
} else if (0 == g_strcmp0(method_name, "GetCaps")) {
GVariantBuilder* vBuilder = g_variant_builder_new("a{sas}");
if (get_caps(vBuilder)) {
g_dbus_method_invocation_return_value(invocation, g_variant_new("(a{sas})", vBuilder));
}
} else if (0 == g_strcmp0(method_name, "GetVersion")) {
GVariantBuilder* vBuilder = g_variant_builder_new("a{ss}");
if (get_version(vBuilder)) {
g_dbus_method_invocation_return_value(invocation, g_variant_new("(a{ss})", vBuilder));
}
} else if (0 == g_strcmp0(method_name, "setPropList")) {
GVariantIter* proplistiter;
g_variant_get(parameters, "(a{ss})", &proplistiter);
g_dbus_method_invocation_return_value(invocation, g_variant_new("(b)", set_prop_list(proplistiter)));
} else if (0 == g_strcmp0(method_name, "setProp")) {
gchar* propName;
gchar* propValue;
g_variant_get(parameters, "(ss)", &propName, &propValue);
g_dbus_method_invocation_return_value(invocation, g_variant_new("(b)", set_prop(propName, propValue)));
}
}
PARSER_RET process_cmd_get(char* buf, uint8_t len) {
uint16_t l;
char tmp[7];
char string[15];
string[0] = 0x00;
if ((len >= 7) && (strncasecmp(buf, "VERSION", 7) == 0)) {
return (PARSER_RET){CMD_OK, get_version()};
}
else if ((len >= 18) && (strncasecmp(buf, "Pulse Width Middle", 18) == 0)) {
l = kicker_get_pulse_width(POS_MIDDLE);
utoa(l, tmp, 10);
return (PARSER_RET){CMD_OK, tmp};
}
else if ((len >= 17) && (strncasecmp(buf, "Pulse Width Right", 17) == 0)) {
l = kicker_get_pulse_width(POS_RIGHT);
utoa(l, tmp, 10);
return (PARSER_RET){CMD_OK, tmp};
}
else if ((len >= 16) && (strncasecmp(buf, "Pulse Width Left", 16) == 0)) {
l = kicker_get_pulse_width(POS_LEFT);
utoa(l, tmp, 10);
return (PARSER_RET){CMD_OK, tmp};
}
else if ((len == 5) && (strncasecmp(buf, "Power", 5) == 0)) {
l = ports_get_adc(POW_12V);
utoa(l, tmp, 10);
strcat(string, tmp);
strcat(string, " ");
l = ports_get_adc(POW_24V);
utoa(l, tmp, 10);
strcat(string, tmp);
return (PARSER_RET){CMD_OK, string};
}
else {
return (PARSER_RET){CMD_ERROR, "Invalid parameter"};
}
}
static void
print_user_internal_error() {
static char error[8];
const char* filename_start = strrchr(err_filename, '/');
if (filename_start)
filename_start++;
else
filename_start = err_filename;
strncpy(error, filename_start, 3);
sprintf(error+3, "%04d", err_lineno);
for (int i = 0; i < 7; i++) {
if (error[i] >= 'a' && error[i] <= 'z') {
error[i] += 'A' - 'a';
}
}
fprintf(stderr, "%s ", error);
char version[128];
get_version(version);
fprintf(stderr, "chpl Version %s", version);
}
System::System (int& argc, char**& argv)
: m_impl(new Impl)
{
visual_log (VISUAL_LOG_INFO, "Starting Libvisual %s", get_version ().c_str ());
#if ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
#endif
// Initialize CPU caps
visual_cpu_initialize ();
// Initialize Mem system
visual_mem_initialize ();
// Initialize high-resolution timer system
TimeSystem::start ();
// Initialize the plugin registry
PluginRegistry::init ();
}
static void header(void)
{
size_t i, x=0;
time_t t;
win_start(header_window, header_color);
mvwprintw(header_window, 0, 0, " ClamdTOP version %s ", get_version());
time(&t);
wprintw(header_window, "%s", ctime(&t));
wrefresh(header_window);
/* win_start(version_window, version_color);
mvwprintw(version_window, 0, 0, "Connected to: ");
print_colored(version_window, clamd_version ? clamd_version : "Unknown");
wrefresh(version_window);*/
werase(status_bar_window);
for(i=0;i<sizeof(status_bar_keys)/sizeof(status_bar_keys[0]);i++) {
const char *s = status_bar_keys[i];
if(!s)
continue;
wattron(status_bar_window, A_REVERSE);
if (s[0] == '^') {
mvwaddch(status_bar_window, 0, x, ACS_UARROW);
s++;
x++;
} else if (s[0] == 'v') {
mvwaddch(status_bar_window, 0, x, ACS_DARROW);
s++;
x++;
}
mvwprintw(status_bar_window, 0, x, "%s",s);
wattroff(status_bar_window, A_REVERSE);
x += strlen(status_bar_keys[i]) + 1;
}
wrefresh(status_bar_window);
}
static void help(void)
{
printf("\n");
printf(" Clam AntiVirus: Bytecode Testing Tool %s\n",
get_version());
printf(" By The ClamAV Team: http://www.clamav.net/about.html#credits\n");
printf(" (C) 2009 Sourcefire, Inc.\n\n");
printf("clambc <file> [function] [param1 ...]\n\n");
printf(" --help -h Show help\n");
printf(" --version -V Show version\n");
printf(" --debug Show debug\n");
printf(" --force-interpreter -f Force using the interpreter instead of the JIT\n");
printf(" --trust-bytecode -t Trust loaded bytecode (default yes)\n");
printf(" --info -i Print information about bytecode\n");
printf(" --printsrc -p Print bytecode source\n");
printf(" --printbcir -c Print IR of bytecode signature\n");
printf(" --trace <level> -T Set bytecode trace level 0..7 (default 7)\n");
printf(" --no-trace-showsource -s Don't show source line during tracing\n");
printf(" --bytecode-statistics Collect and print bytecode execution statistics\n");
printf(" file file to test\n");
printf("\n");
return;
}
std::string stealth_address::encoded() const
{
if (!valid_)
return std::string();
data_chunk raw_address;
raw_address.push_back(get_version());
raw_address.push_back(get_options());
extend_data(raw_address, scan_pubkey_);
// Spend_pubkeys must be guarded against a size greater than 255.
auto number_spend_pubkeys = static_cast<uint8_t>(spend_pubkeys_.size());
// Adjust for key reuse.
if (get_reuse_key())
--number_spend_pubkeys;
raw_address.push_back(number_spend_pubkeys);
// Serialize the spend keys, excluding any that match the scan key.
for (const ec_point& pubkey: spend_pubkeys_)
if (pubkey != scan_pubkey_)
extend_data(raw_address, pubkey);
raw_address.push_back(signatures_);
// The prefix must be guarded against a size greater than 32
// so that the bitfield can convert into uint32_t and sized by uint8_t.
auto prefix_number_bits = static_cast<uint8_t>(prefix_.size());
// Serialize the prefix bytes/blocks.
raw_address.push_back(prefix_number_bits);
extend_data(raw_address, prefix_.blocks());
append_checksum(raw_address);
return encode_base58(raw_address);
}
/** Print some debugging info */
void
SgAsmElfEHFrameEntryCI::dump(FILE *f, const char *prefix, ssize_t idx) const
{
char p[4096];
if (idx>=0) {
sprintf(p, "%sCIE[%zd].", prefix, idx);
} else {
sprintf(p, "%sCIE.", prefix);
}
const int w = std::max(1, DUMP_FIELD_WIDTH-(int)strlen(p));
fprintf(f, "%s%-*s = %d\n", p, w, "version", get_version());
fprintf(f, "%s%-*s = \"%s\"\n", p, w, "augStr", get_augmentation_string().c_str());
fprintf(f, "%s%-*s = %s\n", p, w, "sig_frame", get_sig_frame()?"yes":"no");
fprintf(f, "%s%-*s = 0x%08"PRIx64" (%"PRIu64")\n", p, w, "code_align",
get_code_alignment_factor(), get_code_alignment_factor());
fprintf(f, "%s%-*s = 0x%08"PRIx64" (%"PRId64")\n", p, w, "data_align",
get_data_alignment_factor(), get_data_alignment_factor());
fprintf(f, "%s%-*s = 0x%08"PRIx64" (%"PRIu64")\n", p, w, "aug_length",
get_augmentation_data_length(), get_augmentation_data_length());
fprintf(f, "%s%-*s = %d\n", p, w, "lsda_encoding", get_lsda_encoding());
fprintf(f, "%s%-*s = %d\n", p, w, "prh_encoding", get_prh_encoding());
if (get_prh_encoding()>=0) {
fprintf(f, "%s%-*s = 0x%02x (%u)\n", p, w, "prh_arg", get_prh_arg(), get_prh_arg());
fprintf(f, "%s%-*s = 0x%08"PRIx64" (%"PRIu64")\n", p, w, "prh_addr", get_prh_addr(), get_prh_addr());
}
fprintf(f, "%s%-*s = %d\n", p, w, "addr_encoding", get_addr_encoding());
if (get_instructions().size()>0) {
fprintf(f, "%s%-*s = 0x%08zx (%zu) bytes\n", p, w, "instructions",
get_instructions().size(), get_instructions().size());
hexdump(f, 0, std::string(p)+"insns at ", get_instructions());
}
for (size_t i=0; i<get_fd_entries()->get_entries().size(); i++) {
SgAsmElfEHFrameEntryFD *fde = get_fd_entries()->get_entries()[i];
fde->dump(f, p, i);
}
}
/* returns data_size or a negative number on failure
*/
static int
_gnutls_ext_master_secret_send_params(gnutls_session_t session,
gnutls_buffer_st * extdata)
{
if ((session->internals.flags & GNUTLS_NO_EXTENSIONS) ||
session->internals.priorities->no_extensions != 0 ||
session->internals.no_ext_master_secret != 0) {
session->security_parameters.ext_master_secret = 0;
return 0;
}
/* this function sends the client extension data */
#ifdef ENABLE_SSL3
if (session->security_parameters.entity == GNUTLS_CLIENT) {
if (have_only_ssl3_enabled(session))
return 0; /* this extension isn't available for SSL 3.0 */
return GNUTLS_E_INT_RET_0;
} else { /* server side */
const version_entry_st *ver = get_version(session);
if (unlikely(ver == NULL))
return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
if (ver->id != GNUTLS_SSL3 && session->security_parameters.ext_master_secret != 0)
return GNUTLS_E_INT_RET_0;
}
return 0;
#else
if (session->security_parameters.entity == GNUTLS_CLIENT ||
session->security_parameters.ext_master_secret != 0)
return GNUTLS_E_INT_RET_0;
return 0;
#endif
}
int main(int argc, char *argv[])
{
FILE *fp;
if (argc != 5)
fail("usage: makepkg [key suffix] [version] filename.pkg dir_with_files");
get_keys(argv[1]);
get_files(argv[4]);
get_version(argv[2]);
build_pkg_hdr();
compress_pkg();
build_info_hdr();
build_meta_hdr();
build_sce_hdr();
build_pkg();
calculate_hashes();
sign_hdr();
sce_encrypt_data(pkg);
sce_encrypt_header(pkg, &k);
fp = fopen(argv[3], "wb");
if (fp == NULL)
fail("fopen(%s) failed", argv[3]);
if (fwrite(pkg, pkg_size, 1, fp) != 1)
fail("fwrite failed");
fclose(fp);
return 0;
}
/* Check if the given signature algorithm is supported.
* This means that it is enabled by the priority functions,
* and in case of a server a matching certificate exists.
*/
int
_gnutls_session_sign_algo_enabled(gnutls_session_t session,
gnutls_sign_algorithm_t sig)
{
unsigned i;
const version_entry_st *ver = get_version(session);
if (unlikely(ver == NULL))
return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
if (!_gnutls_version_has_selectable_sighash(ver)) {
return 0;
}
for (i = 0; i < session->internals.priorities.sign_algo.algorithms;
i++) {
if (session->internals.priorities.sign_algo.priority[i] ==
sig) {
return 0; /* ok */
}
}
return GNUTLS_E_UNSUPPORTED_SIGNATURE_ALGORITHM;
}
static int do_getsockopt(struct ip_set_req_get_set *req)
{
int sockfd, res;
socklen_t size = sizeof(struct ip_set_req_get_set);
sockfd = get_version(&req->version);
if (sockfd < 0)
return -1;
res = getsockopt(sockfd, SOL_IP, SO_IP_SET, req, &size);
if (res != 0)
perror("Problem when communicating with ipset");
close(sockfd);
if (res != 0)
return -1;
if (size != sizeof(struct ip_set_req_get_set)) {
fprintf(stderr,
"Incorrect return size from kernel during ipset lookup, (want %zu, got %zu)\n",
sizeof(struct ip_set_req_get_set), (size_t)size);
return -1;
}
return res;
}
System::System (int& argc, char**& argv)
: m_impl(new Impl)
{
visual_log (VISUAL_LOG_INFO, "Starting Libvisual %s", get_version ().c_str ());
#if ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
#endif
__lv_progname = visual_strdup (argv[0]);
/* Initialize CPU caps */
visual_cpu_initialize ();
/* Initialize Mem system */
visual_mem_initialize ();
/* Initialize CPU-accelerated graphics functions */
visual_alpha_blend_initialize ();
/* Initialize high-resolution timer system */
Time::init ();
/* Initialize Thread system */
visual_thread_initialize ();
/* Initialize FFT system */
Fourier::init ();
/* Initialize the plugin registry */
PluginRegistry::init ();
m_impl->params = visual_param_container_new ();
init_params (m_impl->params);
}
/*
* Return values for this function:
* - 0 : Not applicable.
* - >0 : Ok. Return size of extension data.
* - GNUTLS_E_INT_RET_0 : Size of extension data is zero.
* - <0 : There's been an error.
*
* In the client, generates the PskIdentity and PskBinderEntry messages.
*
* PskIdentity identities<7..2^16-1>;
* PskBinderEntry binders<33..2^16-1>;
*
* struct {
* opaque identity<1..2^16-1>;
* uint32 obfuscated_ticket_age;
* } PskIdentity;
*
* opaque PskBinderEntry<32..255>;
*
* The server sends the selected identity, which is a zero-based index
* of the PSKs offered by the client:
*
* struct {
* uint16 selected_identity;
* } PreSharedKeyExtension;
*/
static int _gnutls_psk_send_params(gnutls_session_t session,
gnutls_buffer_t extdata)
{
gnutls_psk_client_credentials_t cred = NULL;
const version_entry_st *vers;
if (session->security_parameters.entity == GNUTLS_CLIENT) {
vers = _gnutls_version_max(session);
if (!vers || !vers->tls13_sem)
return 0;
if (session->internals.hsk_flags & HSK_PSK_KE_MODES_SENT) {
cred = (gnutls_psk_client_credentials_t)
_gnutls_get_cred(session, GNUTLS_CRD_PSK);
}
if ((session->internals.flags & GNUTLS_NO_TICKETS) && !session->internals.priorities->have_psk)
return 0;
return client_send_params(session, extdata, cred);
} else {
vers = get_version(session);
if (!vers || !vers->tls13_sem)
return 0;
if ((session->internals.flags & GNUTLS_NO_TICKETS) && !session->internals.priorities->have_psk)
return 0;
if (session->internals.hsk_flags & HSK_PSK_KE_MODES_RECEIVED)
return server_send_params(session, extdata);
else
return 0;
}
}
int reaver_main(int argc, char **argv)
{
int ret_val = EXIT_FAILURE, r = 0;
time_t start_time = 0, end_time = 0;
struct wps_data *wps = NULL;
globule_init();
init_default_settings();
fprintf(stderr, "\nReaver v%s WiFi Protected Setup Attack Tool\n", get_version());
fprintf(stderr, "Copyright (c) 2011, Tactical Network Solutions, Craig Heffner <*****@*****.**>\n\n");
if(argc < 2)
{
ret_val = reaver_usage(argv[0]);
goto end;
}
/* Process the command line arguments */
if(process_arguments(argc, argv) == EXIT_FAILURE)
{
ret_val = reaver_usage(argv[0]);
goto end;
}
/* Double check reaver_usage */
if(!get_iface() || (memcmp(get_bssid(), NULL_MAC, MAC_ADDR_LEN) == 0))
{
reaver_usage(argv[0]);
goto end;
}
/* If no MAC address was provided, get it ourselves */
if(memcmp(get_mac(), NULL_MAC, MAC_ADDR_LEN) == 0)
{
if(!read_iface_mac())
{
fprintf(stderr, "[-] Failed to retrieve a MAC address for interface '%s'!\n", get_iface());
goto end;
}
}
/* Sanity checking on the message timeout value */
if(get_m57_timeout() > M57_MAX_TIMEOUT)
{
set_m57_timeout(M57_MAX_TIMEOUT);
}
else if(get_m57_timeout() <= 0)
{
set_m57_timeout(M57_DEFAULT_TIMEOUT);
}
/* Sanity checking on the receive timeout value */
if(get_rx_timeout() <= 0)
{
set_rx_timeout(DEFAULT_TIMEOUT);
}
/* Initialize signal handlers */
sigint_init();
sigalrm_init();
/* Mark the start time */
start_time = time(NULL);
/* Do it. */
crack();
/* Mark the end time */
end_time = time(NULL);
/* Check our key status */
if(get_key_status() == KEY_DONE)
{
wps = get_wps();
cprintf(VERBOSE, "[+] Pin cracked in %d seconds\n", (int) (end_time - start_time));
cprintf(CRITICAL, "[+] WPS PIN: '%s'\n", get_pin());
if(wps->key) cprintf(CRITICAL, "[+] WPA PSK: '%s'\n", wps->key);
if(wps->essid) cprintf(CRITICAL, "[+] AP SSID: '%s'\n", wps->essid);
/* Run user-supplied command */
if(get_exec_string())
{
r = system(get_exec_string());
}
ret_val = EXIT_SUCCESS;
}
else
{
cprintf(CRITICAL, "[-] Failed to recover WPA key\n");
}
save_session();
end:
globule_deinit();
return ret_val;
}
static int recv_screen (CalcHandle* handle, CalcScreenCoord* sc, uint8_t** bitmap)
{
int ret;
CalcInfos infos;
// First of all, we have to identify the Nspire model.
ret = get_version(handle, &infos);
if (!ret)
{
if (infos.bits_per_pixel == 4)
{
// Nspire (CAS) Clickpad or Touchpad.
sc->pixel_format = CALC_PIXFMT_GRAY_4;
}
else if (infos.bits_per_pixel == 16)
{
// Nspire (CAS) CX or CM.
sc->pixel_format = CALC_PIXFMT_RGB_565_LE;
}
else
{
ticalcs_critical(_("Unknown calculator model with %d bpp\n"), infos.bits_per_pixel);
return ERR_UNSUPPORTED; // THIS RETURNS !
}
// Do screenshot
ret = nsp_session_open(handle, NSP_SID_SCREEN_RLE);
if (!ret)
{
ret = nsp_cmd_s_screen_rle(handle, 0);
if (!ret)
{
uint32_t size = 0;
uint8_t cmd, *data;
ret = nsp_cmd_r_screen_rle(handle, &cmd, &size, &data);
if (!ret)
{
sc->width = sc->clipped_width = (((uint16_t)data[8]) << 8) | data[9];
sc->height = sc->clipped_height = (((uint16_t)data[10]) << 8) | data[11];
size = ( (((uint32_t)data[0]) << 24)
| (((uint32_t)data[1]) << 16)
| (((uint32_t)data[2]) << 8)
| (((uint32_t)data[3]) ));
g_free(data);
if (sc->width > 320)
{
ticalcs_critical("%s: no calculator model known to this library has screens of width > 320 pixels", __FUNCTION__);
ret = ERR_INVALID_PACKET;
}
else if (sc->height > 240)
{
ticalcs_critical("%s: no calculator model known to this library has screens of height > 240 pixels", __FUNCTION__);
ret = ERR_INVALID_PACKET;
}
else if (size > 2 * sc->width * sc->height)
{
ticalcs_critical("%s: no calculator model known to this library uses more than 16 bpp", __FUNCTION__);
ret = ERR_INVALID_PACKET;
}
else
{
ret = nsp_cmd_r_screen_rle(handle, &cmd, &size, &data);
if (!ret)
{
uint32_t len = sc->width * sc->height * infos.bits_per_pixel / 8;
uint8_t * dst = ticalcs_alloc_screen(len);
if (dst != NULL)
{
ret = ticalcs_screen_nspire_rle_uncompress(sc->pixel_format, data, size, dst, len);
if (!ret)
{
*bitmap = dst;
}
else
{
ticalcs_free_screen(dst);
}
}
else
{
ret = ERR_MALLOC;
}
g_free(data);
}
}
}
}
DO_CLOSE_SESSION(handle);
}
}
return ret;
}
