static const char * rdv_peel_base(void) { const char *response = NULL; const char *nep; json_error_t error; json_t *root; /* Just in case */ fassert(ONION_TYPE(l_current_onion) == BASE); nep = (char *)ONION_DATA(l_current_onion); log_dbg("nep = %s", nep); root = json_loads(nep, 0, &error); if (root != NULL) { /* Pass the NET to ACS so that it can Dance */ acs_set_net(root); /* XXX: might fail if already dancing, check return */ response = rdv_make_peel_response( "NET passed to ACS", "Complete"); /* Done with it here */ json_decref(root); } else { log_dbg("data = %s error: line: %d msg: %s", nep, error.line, error.text); response = rdv_make_peel_response( "Sorry your nep did not parse as JSON", ""); } return (response); }
static int check_regex(regex_t *re, char *regex, char *s) { int ret; #if(_debug_) log_dbg("Checking %s =~ %s", s, regex); #endif #if defined (__FreeBSD__) || defined (__APPLE__) || defined (__OpenBSD__) || defined (__NetBSD__) if (!re->re_g) #else if (!re->allocated) #endif { if ((ret = regcomp(re, regex, REG_EXTENDED | REG_NOSUB)) != 0) { char error[512]; regerror(ret, re, error, sizeof(error)); log_err(0, "regcomp(%s) failed (%s)", regex, error); regex[0] = 0; return -1; } } if ((ret = regexec(re, s, 0, 0, 0)) == 0) { log_dbg("Matched regex %s", regex); return 0; } return 1; }
static int LUKS_check_device_size(struct crypt_device *ctx, size_t keyLength) { struct device *device = crypt_metadata_device(ctx); uint64_t dev_sectors, hdr_sectors; if (!keyLength) return -EINVAL; if(device_size(device, &dev_sectors)) { log_dbg("Cannot get device size for device %s.", device_path(device)); return -EIO; } dev_sectors >>= SECTOR_SHIFT; hdr_sectors = LUKS_device_sectors(keyLength); log_dbg("Key length %zu, device size %" PRIu64 " sectors, header size %" PRIu64 " sectors.",keyLength, dev_sectors, hdr_sectors); if (hdr_sectors > dev_sectors) { log_err(ctx, _("Device %s is too small. (LUKS requires at least %" PRIu64 " bytes.)\n"), device_path(device), hdr_sectors * SECTOR_SIZE); return -EINVAL; } return 0; }
int SSL_accept2(SSL *ssl) { char buf[1024]; int rc; #if(_debug_) log_dbg("MatrixSSL_accept2()"); #endif rc = _ssl_read(ssl, buf, sizeof(buf)); if (rc == 0) { if (ssl->status == SSL_SOCKET_EOF || ssl->status == SSL_SOCKET_CLOSE_NOTIFY) { log_dbg("EOF or Closed"); return -1; } return 0; } else if (rc > 0) { log_dbg("Accept2() returning %d", rc); return rc; } else { if (ssl->status == EAGAIN || ssl->status == EWOULDBLOCK) return 0; log_warn(ssl->status, "Error rc %d", rc); return -1; } return 1; }
static void cb_conn_read_cli(struct bufferevent *bev, void *user_data) { void* buffer = NULL; uint32_t buf_len = 0; struct evbuffer *buf_in = bufferevent_get_input(bev); cli_cmd_t cmd; cstr *json = cstr_new(); cli_cmd_init(&cmd); /* bufferevent_lock(bev); */ /* read data frome buffer in */ buf_len = evbuffer_get_length(buf_in); buffer = calloc(1, buf_len); bufferevent_read(bev, buffer, buf_len); /* bufferevent_unlock(bev); */ log_dbg("recv command: %s", (char*)buffer); cli_parse(&cmd, (char*)buffer); cli_cmd_to_json(&cmd, json); log_dbg("cli response: %s", cstr_body(json)); bufferevent_send(bev, cstr_body(json), cstr_len(json) + 1); /* put data to addr recv buffer, and translate to command format */ cli_cmd_release(&cmd); cstr_free(json); free(buffer); /* bufferevent_free(bev); */ }
static VALUE ruby_function_proxy(VALUE self, VALUE _args) { ID id = rb_frame_last_func(); value_t* value = dict_lookup(global->functions, (void*)id); if(!value) { language_error(global->li, "[ruby] couldn't retrieve constant %s", rb_id2name(id)); return Qnil; } if(value->type == TYPE_FUNCTION) { log_dbg("[ruby] calling function %s", rb_id2name(id)); value_t*args = ruby_to_value(_args); value_t*ret = value->call(value, args); value_destroy(args); volatile VALUE r = value_to_ruby(ret); value_destroy(ret); log_dbg("[rb] returning from callback"); return r; } else { log_dbg("[ruby] retrieving constant %s (%s)", rb_id2name(id), type_to_string(value->type)); volatile VALUE r = value_to_ruby(value); return r; } return Qnil; }
static void request_auth_child(void) { int sock; int ret; struct sockaddr_in serveraddr; sock = socket (PF_INET, SOCK_STREAM, 0); if ((sock > 0) && init_sockaddr(&serveraddr, HOSTNAME, SERV_TCP_PORT)) { log_dbg("connecting to auth server at %s", inet_ntoa(serveraddr.sin_addr)); while(1) { ret = connect(sock, (struct sockaddr*) &serveraddr, sizeof(serveraddr)); if (ret == ENETUNREACH) { log_dbg("network unreachable - reconnecting"); sleep(RECONNECT_DELAY); } else break; } if (!ret) { log_dbg("sending init request"); send(sock, "IMAL", 4, 0); } else log_dbg("connect error: %s", strerror(errno)); close(sock); } }
static int validate_luks2_json_object(json_object *jobj_hdr) { int r; /* we require top level object to be of json_type_object */ r = !json_object_is_type(jobj_hdr, json_type_object); if (r) { log_dbg("ERROR: Resulting object is not a json object type"); return r; } r = LUKS2_hdr_validate(jobj_hdr); if (r) { log_dbg("Repairing JSON metadata."); /* try to correct known glitches */ LUKS2_hdr_repair(jobj_hdr); /* run validation again */ r = LUKS2_hdr_validate(jobj_hdr); } if (r) log_dbg("ERROR: LUKS2 validation failed"); return r; }
static int _conn_bstring_readhandler(struct conn_t *conn, void *ctx) { bstring data = (bstring)ctx; int ret; ballocmin(data, data->slen + 128); ret = safe_read(conn->sock, data->data + data->slen, data->mlen - data->slen); if (ret > 0) { #if(_debug_) log_dbg("bstring_read: %d bytes", ret); #endif data->slen += ret; } else { #if(_debug_) log_dbg("socket closed!"); log_dbg("<== [%s]", data->data); #endif conn_finish(conn); } return ret; }
static int validate_json_area(const char *json_area, int start, int length) { char c; /* Enforce there are no needless opening bytes */ if (*json_area != '{') { log_dbg("ERROR: Opening character must be left curly bracket: '{'."); return -EINVAL; } if (start >= length) { log_dbg("ERROR: Missing trailing null byte beyond parsed json data string."); return -EINVAL; } /* * TODO: * validate there are legal json format characters between * 'json_area' and 'json_area + start' */ do { c = *(json_area + start); if (c != '\0') { log_dbg("ERROR: Forbidden ascii code 0x%02hhx found beyond json data string at offset %d.", c, start); return -EINVAL; } } while (++start < length); return 0; }
static int LUKS2_check_device_size(struct crypt_device *cd, struct device *device, uint64_t hdr_size, int falloc) { uint64_t dev_size; if (device_size(device, &dev_size)) { log_dbg("Cannot get device size for device %s.", device_path(device)); return -EIO; } log_dbg("Device size %" PRIu64 ", header size %" PRIu64 ".", dev_size, hdr_size); if (hdr_size > dev_size) { /* If it is header file, increase its size */ if (falloc && !device_fallocate(device, hdr_size)) return 0; log_err(cd, _("Device %s is too small. (LUKS2 requires at least %" PRIu64 " bytes.)"), device_path(device), hdr_size); return -EINVAL; } return 0; }
/* * Helper functions */ json_object *parse_json_len(const char *json_area, int length, int *end_offset) { json_object *jobj; struct json_tokener *jtok; if (!json_area || length <= 0) return NULL; jtok = json_tokener_new(); if (!jtok) { log_dbg("ERROR: Failed to init json tokener"); return NULL; } jobj = json_tokener_parse_ex(jtok, json_area, length); if (!jobj) log_dbg("ERROR: Failed to parse json data (%d): %s", json_tokener_get_error(jtok), json_tokener_error_desc(json_tokener_get_error(jtok))); else *end_offset = jtok->char_offset; json_tokener_free(jtok); return jobj; }
/* Try to open a particular key slot */ static int LUKS_open_key(unsigned int keyIndex, const char *password, size_t passwordLen, struct luks_phdr *hdr, struct volume_key *vk, struct crypt_device *ctx) { crypt_keyslot_info ki = LUKS_keyslot_info(hdr, keyIndex); struct volume_key *derived_key; char *AfKey; size_t AFEKSize; int r; log_dbg("Trying to open key slot %d [%s].", keyIndex, dbg_slot_state(ki)); if (ki < CRYPT_SLOT_ACTIVE) return -ENOENT; derived_key = crypt_alloc_volume_key(hdr->keyBytes, NULL); if (!derived_key) return -ENOMEM; assert(vk->keylength == hdr->keyBytes); AFEKSize = AF_split_sectors(vk->keylength, hdr->keyblock[keyIndex].stripes) * SECTOR_SIZE; AfKey = crypt_safe_alloc(AFEKSize); if (!AfKey) { r = -ENOMEM; goto out; } r = crypt_pbkdf("pbkdf2", hdr->hashSpec, password, passwordLen, hdr->keyblock[keyIndex].passwordSalt, LUKS_SALTSIZE, derived_key->key, hdr->keyBytes, hdr->keyblock[keyIndex].passwordIterations); if (r < 0) goto out; log_dbg("Reading key slot %d area.", keyIndex); r = LUKS_decrypt_from_storage(AfKey, AFEKSize, hdr->cipherName, hdr->cipherMode, derived_key, hdr->keyblock[keyIndex].keyMaterialOffset, ctx); if (r < 0) goto out; r = AF_merge(AfKey,vk->key,vk->keylength,hdr->keyblock[keyIndex].stripes,hdr->hashSpec); if (r < 0) goto out; r = LUKS_verify_volume_key(hdr, vk); if (!r) log_verbose(ctx, _("Key slot %d unlocked.\n"), keyIndex); out: crypt_safe_free(AfKey); crypt_free_volume_key(derived_key); return r; }
/* * Return values: * 0 == nothing to write * -1 == error that closed socket * 1 == normal write */ static int redir_cli_rewrite(redir_request *req, struct conn_t *conn) { if (conn_write_remaining(conn)) { int w = net_write(req->socket_fd, conn->read_buf->data + conn->read_pos, conn->read_buf->slen - conn->read_pos); if (w < 0 && errno != EWOULDBLOCK && errno != EAGAIN) { log_err(errno, "net_write(%d)", conn->read_buf->slen - conn->read_pos); redir_conn_finish(conn, req); return -1; } else if (w > 0) { #if(_debug_) log_dbg("client (re)write: %d", w); #endif conn->read_pos += w; if (conn->read_pos == conn->read_buf->slen) { log_dbg("emptying write queue"); conn->read_pos = 0; bassigncstr(conn->read_buf, ""); } } return 1; } return 0; }
static void conn_eventcb_async(struct bufferevent *bev, short events, void *user_data) { addr_t* addr = (addr_t*)user_data; addr_sock_t *addr_sock = (addr_sock_t*)addr_get_addr_info(addr); bool is_error = false; if (events & BEV_EVENT_EOF) { is_error = true; log_dbg("Connection(dev:%s type:%s) closed.", addr_get_dev_name(addr), addr_get_type_name(addr)); } else if (events & BEV_EVENT_ERROR) { is_error = true; log_dbg("Got an error on the connection: %s", strerror(errno));/*XXX win32*/ } else { log_dbg("conn_eventcb other"); } if(is_error){ addr_sock->fd = SOCK_FD_INVALID; addr_sock->bev = NULL; bufferevent_free(bev); } /* None of the other events can happen here, since we haven't enabled * timeouts */ /* bufferevent_free(bev); */ }
int pass_through_rem(pass_through * ptlist, uint32_t * ptcnt, pass_through * pt #ifdef HAVE_PATRICIA , patricia_tree_t * ptree #endif ) { uint32_t cnt = *ptcnt; int i; for (i = 0; i < cnt; i++) { if (pt_equal(&ptlist[i], pt)) { log_dbg ("Uamallowed removing #%d: proto=%d host=%s port=%d", i, pt->proto, inet_ntoa(pt->host), pt->port); log_dbg("Shifting uamallowed list %d to %d", i, cnt); for (; i < cnt - 1; i++) memcpy(&ptlist[i], &ptlist[i + 1], sizeof(pass_through)); *ptcnt = *ptcnt - 1; break; } } #ifdef HAVE_PATRICIA if (ptree) garden_patricia_rem(pt, ptree); #endif return 0; }
static int LUKS_check_device_size(struct crypt_device *ctx, const struct luks_phdr *hdr, int falloc) { struct device *device = crypt_metadata_device(ctx); uint64_t dev_sectors, hdr_sectors; if (!hdr->keyBytes) return -EINVAL; if (device_size(device, &dev_sectors)) { log_dbg("Cannot get device size for device %s.", device_path(device)); return -EIO; } dev_sectors >>= SECTOR_SHIFT; hdr_sectors = LUKS_device_sectors(hdr); log_dbg("Key length %u, device size %" PRIu64 " sectors, header size %" PRIu64 " sectors.", hdr->keyBytes, dev_sectors, hdr_sectors); if (hdr_sectors > dev_sectors) { /* If it is header file, increase its size */ if (falloc && !device_fallocate(device, hdr_sectors << SECTOR_SHIFT)) return 0; log_err(ctx, _("Device %s is too small. (LUKS1 requires at least %" PRIu64 " bytes.)"), device_path(device), hdr_sectors * SECTOR_SIZE); return -EINVAL; } return 0; }
int socket_cli_send_request(const char *ip, uint16_t port, const char *request_str) { int fd = 0; int write_cnt = 0; struct sockaddr_in saddr; fd = Socket(AF_INET, SOCK_STREAM, 0); saddr.sin_family = AF_INET; saddr.sin_port = htons(port); inet_aton(ip, (struct in_addr*)&(saddr.sin_addr.s_addr)); if(connect(fd, (struct sockaddr *)(&saddr), sizeof(struct sockaddr_in)) < 0) { log_dbg("connect to %s:%d failed: %s", ip, port, strerror(errno)); } log_dbg("connect to %s:%d OK", ip, port); write_cnt = write(fd, request_str, strlen(request_str) + 1); if(write_cnt != strlen(request_str) + 1) { log_dbg("%s failed, we want %d but recv %d", __FUNCTION__, strlen(request_str) + 1, write_cnt); fd = -1; SOCKET_CLOSE(fd); } return fd; }
/* Get data size in bytes */ int device_size(struct device *device, uint64_t *size) { struct stat st; int devfd, r = -EINVAL; log_dbg("device_size: %s", device->path); devfd = open(device->path, O_RDONLY); if(devfd == -1) return -EINVAL; if (fstat(devfd, &st) < 0) goto out; if (S_ISREG(st.st_mode)) { *size = (uint64_t)st.st_size; log_dbg("st size: %llu", *size); r = 0; } else if (ioctl(devfd, BLKGETSIZE64, size) >= 0) { log_dbg("ioctl size: %llu", *size); r = 0; } out: close(devfd); return r; }
static void max14688_irq_button_pressed (struct max14688 *me) { int micZ; /* Make sure no button down */ max14688_irq_button_released(me); /* Read MIC impedences */ micZ = me->read_mic_impedence(me->dev); /* Look up button matching impedence ranges */ max14688_lookup_button(me, micZ); log_dbg("%s[micZ = %d]\n", __func__, micZ); if (unlikely(!__present_valid_button(me))) { log_warn("unknown button - mic %d\n", micZ); goto out; } log_dbg("button %s pressed\n", __current_button_name(me)); me->report_button(me->dev, __current_button(me), BUTTON_DOWN_VALUE); out: return; }
static int max14688_read_left_impedence (struct device *dev) { struct max14688 *me = dev_get_drvdata(dev); u8 adcconversion = 0; u8 adcstatus = 0; int rc; rc = max14688_read(me, ADCCONVERSION, &adcconversion); if (unlikely(rc)) { log_err("ADCCONVERSION read error [%d]\n", rc); goto out; } log_dbg("%s[adc value = %d]\n", __func__, adcconversion); /* Greater than 2.69k(ohm) resistor is connected, read the EOC bit in the ADCSTATUS address */ max14688_read(me, ADCSTATUS, &adcstatus); if (!(BITS_GET(adcstatus, ADCSTATUS_EOC))) { log_dbg("%s[ADC_VAL_MAX = %d]\n", __func__, (int)ADC_VAL_MAX); rc = (int)ADC_VAL_MAX; } else { rc = (int)adcconversion; } out: return rc; }
/* * Sanity checks before checksum is validated */ static int hdr_disk_sanity_check_pre(struct luks2_hdr_disk *hdr, size_t *hdr_json_size, int secondary, uint64_t offset) { if (memcmp(hdr->magic, secondary ? LUKS2_MAGIC_2ND : LUKS2_MAGIC_1ST, LUKS2_MAGIC_L)) return -EINVAL; if (be16_to_cpu(hdr->version) != 2) { log_dbg("Unsupported LUKS2 header version %u.", be16_to_cpu(hdr->version)); return -EINVAL; } if (offset != be64_to_cpu(hdr->hdr_offset)) { log_dbg("LUKS2 offset 0x%04x on device differs to expected offset 0x%04x.", (unsigned)be64_to_cpu(hdr->hdr_offset), (unsigned)offset); return -EINVAL; } /* FIXME: sanity check checksum alg. */ log_dbg("LUKS2 header version %u of size %u bytes, checksum %s.", (unsigned)be16_to_cpu(hdr->version), (unsigned)be64_to_cpu(hdr->hdr_size), hdr->checksum_alg); *hdr_json_size = be64_to_cpu(hdr->hdr_size) - LUKS2_HDR_BIN_LEN; return 0; }
int pass_through_add(pass_through * ptlist, uint32_t ptlen, uint32_t * ptcnt, pass_through * pt, char is_dyn #ifdef HAVE_PATRICIA , patricia_tree_t * ptree #endif ) { uint32_t cnt = *ptcnt; int i; for (i = 0; i < cnt; i++) { if (pt_equal(&ptlist[i], pt)) { log_dbg ("Uamallowed already exists #%d:%d: proto=%d host=%s port=%d", i, ptlen, pt->proto, inet_ntoa(pt->host), pt->port); if (is_dyn) { log_dbg("Shifting uamallowed list %d to %d", i, cnt); for (; i < cnt - 1; i++) memcpy(&ptlist[i], &ptlist[i + 1], sizeof(pass_through)); cnt = *ptcnt = *ptcnt - 1; break; } else { return 0; } } } if (cnt == ptlen) { if (!is_dyn) { log_dbg("No more room for walled garden entries"); return -1; } log_dbg("Shifting uamallowed list %d to %d", i, ptlen); for (i = 0; i < ptlen - 1; i++) memcpy(&ptlist[i], &ptlist[i + 1], sizeof(pass_through)); cnt = *ptcnt = *ptcnt - 1; } log_dbg("Uamallowed IP address #%d:%d: proto=%d host=%s port=%d", cnt, ptlen, pt->proto, inet_ntoa(pt->host), pt->port); memcpy(&ptlist[cnt], pt, sizeof(pass_through)); *ptcnt = cnt + 1; #ifdef HAVE_PATRICIA if (ptree) garden_patricia_add(pt, ptree); #endif return 0; }
static void max14688_det_work (struct work_struct *work) { struct max14688 *me = container_of(work, struct max14688, det_work.work); int micZ, leftZ; if(earjack_detect == true) { log_dbg("duplication intterupt already connect earjack\n"); return; } else { earjack_detect = true; } __lock(me); if (unlikely(!me->detect_jack(me->dev))) { log_warn("no jack in detection work\n"); earjack_detect = false; goto out; } max14688_update_status(me); /* Read MIC and L-line impedences */ micZ = me->read_mic_impedence(me->dev); leftZ = me->read_left_impedence(me->dev); log_dbg("%s[micZ = %d, leftZ = %d\n", __func__, micZ, leftZ); /* Look up jack matching impedence ranges */ max14688_lookup_jack(me, micZ, leftZ); if (unlikely(!__present_valid_jack(me))) { earjack_detect = false; goto no_match_found; } max14688_write_mode0(me, __current_jack_mode0(me)); max14688_write_mode1(me, __current_jack_mode1(me)); if (__current_jack_has_button(me)) { max14688_enable_irq(me, IRQ_SWD); } else { max14688_disable_irq(me, IRQ_SWD); } log_dbg("jack %s inserted\n", __current_jack_name(me)); me->report_jack(me->dev, __current_jack(me), JACK_IN_VALUE); goto out; no_match_found: /* Handle exception */ log_err("unknown jack - mic %d, left %d\n", micZ, leftZ); out: __unlock(me); return; }
static int TCRYPT_hdr_from_disk(struct tcrypt_phdr *hdr, struct crypt_params_tcrypt *params, int kdf_index, int cipher_index) { uint32_t crc32; size_t size; /* Check CRC32 of header */ size = TCRYPT_HDR_LEN - sizeof(hdr->d.keys) - sizeof(hdr->d.header_crc32); crc32 = crypt_crc32(~0, (unsigned char*)&hdr->d, size) ^ ~0; if (be16_to_cpu(hdr->d.version) > 3 && crc32 != be32_to_cpu(hdr->d.header_crc32)) { log_dbg("TCRYPT header CRC32 mismatch."); return -EINVAL; } /* Check CRC32 of keys */ crc32 = crypt_crc32(~0, (unsigned char*)hdr->d.keys, sizeof(hdr->d.keys)) ^ ~0; if (crc32 != be32_to_cpu(hdr->d.keys_crc32)) { log_dbg("TCRYPT keys CRC32 mismatch."); return -EINVAL; } /* Convert header to cpu format */ hdr->d.version = be16_to_cpu(hdr->d.version); hdr->d.version_tc = be16_to_cpu(hdr->d.version_tc); hdr->d.keys_crc32 = be32_to_cpu(hdr->d.keys_crc32); hdr->d.hidden_volume_size = be64_to_cpu(hdr->d.hidden_volume_size); hdr->d.volume_size = be64_to_cpu(hdr->d.volume_size); hdr->d.mk_offset = be64_to_cpu(hdr->d.mk_offset); if (!hdr->d.mk_offset) hdr->d.mk_offset = 512; hdr->d.mk_size = be64_to_cpu(hdr->d.mk_size); hdr->d.flags = be32_to_cpu(hdr->d.flags); hdr->d.sector_size = be32_to_cpu(hdr->d.sector_size); if (!hdr->d.sector_size) hdr->d.sector_size = 512; hdr->d.header_crc32 = be32_to_cpu(hdr->d.header_crc32); /* Set params */ params->passphrase = NULL; params->passphrase_size = 0; params->hash_name = tcrypt_kdf[kdf_index].hash; params->key_size = tcrypt_cipher[cipher_index].chain_key_size; params->cipher = tcrypt_cipher[cipher_index].long_name; params->mode = tcrypt_cipher[cipher_index].mode; return 0; }
static void prf_set(httpsrv_client_t *hcl) { if (hcl->readbody == NULL) { if (hcl->headers.content_length == 0) { djb_error(hcl, 400, "Setting preferences requires a length"); return; } if (httpsrv_readbody_alloc(hcl, 0, 0) < 0) { log_wrn("httpsrv_readbody_alloc() failed"); } /* Let httpsrv read */ return; } log_dbg("prefs = %s", hcl->readbody); mutex_lock(l_mutex); if (l_current_preferences != NULL) free(l_current_preferences); l_current_preferences = (hcl->readbody == NULL ? NULL : strdup(hcl->readbody)); if (prf_parse_preferences()) { #if DEBUGHANDLE /* this block is just for testing */ unsigned int argc = 0, i; char **argv = NULL; for (i = 0; i < PRF_MAX; i++) { if (l_keys[i] == NULL) continue; if (l_values[i] == NULL) continue; log_dbg("%s => %s\n", l_keys[i], l_values[i]); } argc = prf_get_argv(&argv); log_wrn("argc = %u", argc); for (i = 0; i < argc; i++) { log_dbg("argv[%u] = %s\n", i, argv[i]); } #endif djb_result(hcl, DJB_OK, "Preferences OK"); } else { djb_result(hcl, DJB_OK, "Preferences broken"); } mutex_unlock(l_mutex); }
static const char * rdv_peel_captcha_no_image_path(void) { int retcode; const char *path, *ret; fassert(l_current_image_dir != NULL); l_captcha_image_path = aprintf("%s" PATH_SEPARATOR "captcha.png", l_current_image_dir); if (l_captcha_image_path == NULL) { return (NULL); } log_dbg("Captcha image = %s", l_captcha_image_path); retcode = bytes2file(l_captcha_image_path, ONION_PUZZLE_SIZE(l_current_onion), ONION_PUZZLE(l_current_onion)); if (retcode != DEFIANT_OK) { log_dbg("Could not store captcha to %s: %s", l_captcha_image_path, defiant_strerror(retcode)); /* Failed, thus clean up */ aprintf_free(l_captcha_image_path); l_captcha_image_path = NULL; return (NULL); } path = aprintf( "/rendezvous/file%s", l_captcha_image_path); if (path == NULL) { ret = NULL; } else { /* Our captcha image */ ret = rdv_make_peel_response(path, "Here is your captcha image!"); /* Free temporary path */ aprintf_free(path); } if (ret == NULL) { /* Failed, thus clean up */ aprintf_free(l_captcha_image_path); l_captcha_image_path = NULL; } return (ret); }
static void _dm_set_crypt_compat(int maj, int min, int patch) { log_dbg("Detected dm-crypt target of version %i.%i.%i.", maj, min, patch); if (maj >= 1 && min >=2) _dm_crypt_wipe_key_supported = 1; else log_dbg("Suspend and resume disabled, no wipe key support."); _dm_crypt_checked = 1; }
int crypt_memlock_dec(struct crypt_device *ctx) { if (_memlock_count && (!--_memlock_count)) { log_dbg("Unlocking memory."); if (munlockall() == -1) log_err(ctx, _("Cannot unlock memory.")); if (setpriority(PRIO_PROCESS, 0, _priority)) log_dbg("setpriority %d failed: %s", _priority, strerror(errno)); } return _memlock_count ? 1 : 0; }
static int TCRYPT_decrypt_hdr(struct crypt_device *cd, struct tcrypt_phdr *hdr, const char *key, uint32_t flags) { struct tcrypt_phdr hdr2; int i, j, r = -EINVAL; for (i = 0; tcrypt_cipher[i].chain_count; i++) { if (!(flags & CRYPT_TCRYPT_LEGACY_MODES) && tcrypt_cipher[i].legacy) continue; log_dbg("TCRYPT: trying cipher %s-%s", tcrypt_cipher[i].long_name, tcrypt_cipher[i].mode); memcpy(&hdr2.e, &hdr->e, TCRYPT_HDR_LEN); if (!strncmp(tcrypt_cipher[i].mode, "cbci", 4)) r = TCRYPT_decrypt_cbci(&tcrypt_cipher[i], key, &hdr2); else for (j = tcrypt_cipher[i].chain_count - 1; j >= 0 ; j--) { if (!tcrypt_cipher[i].cipher[j].name) continue; r = TCRYPT_decrypt_hdr_one(&tcrypt_cipher[i].cipher[j], tcrypt_cipher[i].mode, key, &hdr2); if (r < 0) break; } if (r < 0) { log_dbg("TCRYPT: returned error %d, skipped.", r); if (r == -ENOTSUP) break; r = -ENOENT; continue; } if (!strncmp(hdr2.d.magic, TCRYPT_HDR_MAGIC, TCRYPT_HDR_MAGIC_LEN)) { log_dbg("TCRYPT: Signature magic detected."); memcpy(&hdr->e, &hdr2.e, TCRYPT_HDR_LEN); r = i; break; } if ((flags & CRYPT_TCRYPT_VERA_MODES) && !strncmp(hdr2.d.magic, VCRYPT_HDR_MAGIC, TCRYPT_HDR_MAGIC_LEN)) { log_dbg("TCRYPT: Signature magic detected (Veracrypt)."); memcpy(&hdr->e, &hdr2.e, TCRYPT_HDR_LEN); r = i; break; } r = -EPERM; } crypt_memzero(&hdr2, sizeof(hdr2)); return r; }