int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len)
{
u32 *digest = (u32 *) digest_buf;
tc_t *tc = (tc_t *) esalt_buf;
const float entropy = get_entropy ((const u8 *) line_buf, line_len);
if (entropy < MIN_SUFFICIENT_ENTROPY_FILE) return (PARSER_INSUFFICIENT_ENTROPY);
memcpy (tc->salt_buf, line_buf, 64);
memcpy (tc->data_buf, line_buf + 64, 512 - 64);
salt->salt_buf[0] = tc->salt_buf[0];
salt->salt_len = 4;
salt->salt_iter = ROUNDS_TRUECRYPT_1K - 1;
tc->signature = 0x45555254; // "TRUE"
digest[0] = tc->data_buf[0];
return (PARSER_OK);
}
int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len)
{
u32 *digest = (u32 *) digest_buf;
vc_t *vc = (vc_t *) esalt_buf;
const float entropy = get_entropy ((const u8 *) line_buf, line_len);
if (entropy < MIN_SUFFICIENT_ENTROPY_FILE) return (PARSER_INSUFFICIENT_ENTROPY);
memcpy (vc->salt_buf, line_buf, 64);
memcpy (vc->data_buf, line_buf + 64, 512 - 64);
salt->salt_buf[0] = vc->salt_buf[0];
salt->salt_len = 4;
salt->salt_iter = ROUNDS_VERACRYPT_200000;
salt->salt_iter--;
vc->pim_multi = 2048;
vc->pim_start = 0;
vc->pim_stop = 0;
vc->signature = 0x41524556; // "VERA"
digest[0] = vc->data_buf[0];
return (PARSER_OK);
}
static int
get_bytes(const char *path, unsigned char *outdata, int size)
{
size_t len;
int fd, ret = 1;
if (path == NULL)
path = egd_path;
fd = connect_egd(path);
if (fd < 0)
return 0;
while(size) {
len = size;
if (len > MAX_EGD_DATA)
len = MAX_EGD_DATA;
ret = get_entropy(fd, outdata, len);
if (ret != 1)
break;
outdata += len;
size -= len;
}
close(fd);
return ret;
}
void mk_challenge (unsigned char *c, int length)
{
get_entropy(c, length);
/* int x;
int *s = (int *) c;
for (x = 0; x < length / sizeof (int); x++)
s[x] = rand (); */
}
/* Initializes 'buffer' with 'n' bytes of high-quality random numbers. Exits
* if an error occurs. */
void
get_entropy_or_die(void *buffer, size_t n)
{
int error = get_entropy(buffer, n);
if (error) {
VLOG_FATAL("%s: read error (%s)",
urandom, ovs_retval_to_string(error));
}
}
struct tunnel *new_tunnel ()
{
struct tunnel *tmp = calloc (1, sizeof (struct tunnel));
unsigned char entropy_buf[2] = "\0";
if (!tmp)
return NULL;
tmp->debug = 0;
tmp->tid = -1;
memset(&tmp->rt, 0, sizeof(tmp->rt));
#ifndef TESTING
/* while(get_call((tmp->ourtid = rand() & 0xFFFF),0,0,0)); */
/* tmp->ourtid = rand () & 0xFFFF; */
/* get_entropy((char *)&tmp->ourtid, 2); */
get_entropy(entropy_buf, 2);
{
unsigned short *temp;
temp = (unsigned short *)entropy_buf;
tmp->ourtid = *temp & 0xFFFF;
#ifdef DEBUG_ENTROPY
l2tp_log(LOG_DEBUG, "ourtid = %u, entropy_buf = %hx\n", tmp->ourtid, *temp);
#endif
}
#else
tmp->ourtid = 0x6227;
#endif
tmp->peer.sin_family = AF_INET;
bzero (&(tmp->peer.sin_addr), sizeof (tmp->peer.sin_addr));
#ifdef SANITY
tmp->sanity = -1;
#endif
tmp->qtid = -1;
tmp->ourfc = ASYNC_FRAMING | SYNC_FRAMING;
tmp->ourtb = (((_u64) rand ()) << 32) | ((_u64) rand ());
tmp->fc = -1; /* These really need to be specified by the peer */
tmp->bc = -1; /* And we want to know if they forgot */
if (!(tmp->self = new_call (tmp)))
{
free (tmp);
return NULL;
};
tmp->ourrws = DEFAULT_RWS_SIZE;
tmp->self->ourfbit = FBIT;
tmp->rxspeed = DEFAULT_RX_BPS;
tmp->txspeed = DEFAULT_TX_BPS;
memset (tmp->chal_us.reply, 0, MD_SIG_SIZE);
memset (tmp->chal_them.reply, 0, MD_SIG_SIZE);
tmp->chal_them.vector = (unsigned char *) malloc (VECTOR_SIZE);
return tmp;
}
void MsDrbg::reseed(biglong& intenal_state, const size_t byte_len, const string& additional_input_string)
{
unsigned char* entropy_input = get_entropy(byte_len);
unsigned char* internal_bytes = nullptr;
size_t internal_size = intenal_state.get_raw_bytes(internal_bytes);
unsigned char* internal_entropy_bytes = concatenate(internal_bytes,
internal_size, entropy_input, byte_len);
size_t internal_entropy_size = internal_size + byte_len;
delete[] entropy_input;
delete[] internal_bytes;
unsigned char* internal_entropy_additional_bytes = concatenate(internal_entropy_bytes, internal_entropy_size,
additional_input_string.c_str(),
additional_input_string.length());
size_t internal_entropy_additional_size = internal_entropy_size + additional_input_string.length();
delete[] internal_entropy_bytes;
intenal_state = hash_df_hex(internal_entropy_additional_bytes, internal_entropy_additional_size, byte_len);
delete[] internal_entropy_additional_bytes;
}
/*
* HMAC_DRBG reseeding: 10.1.2.4 (arabic) + 9.2 (Roman)
*/
int mbedtls_hmac_drbg_reseed( mbedtls_hmac_drbg_context *ctx,
const unsigned char *additional, size_t len )
{
unsigned char seed[MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT];
size_t seedlen;
size_t entropy_len;
/* III. Check input length */
entropy_len = ctx->entropy_len;
if( len > MBEDTLS_HMAC_DRBG_MAX_INPUT ||
entropy_len + len > MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT )
//ctx->entropy_len + len > MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT )
{
return( MBEDTLS_ERR_HMAC_DRBG_INPUT_TOO_BIG );
}
memset( seed, 0, MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT );
/* IV. Gather entropy_len bytes of entropy for the seed */
//if( ctx->f_entropy( ctx->p_entropy, seed, ctx->entropy_len ) != 0 )
if( get_entropy(seed, entropy_len ) != 0 )
return( MBEDTLS_ERR_HMAC_DRBG_ENTROPY_SOURCE_FAILED );
seedlen = entropy_len;
/* 1. Concatenate entropy and additional data if any */
if( additional != NULL && len != 0 )
{
memcpy( seed + seedlen, additional, len );
seedlen += len;
}
/* 2. Update state */
mbedtls_hmac_drbg_update( ctx, seed, seedlen );
/* 3. Reset reseed_counter */
ctx->reseed_counter = 1;
/* 4. Done */
return( 0 );
}
struct tunnel *new_tunnel ()
{
struct tunnel *tmp = malloc (sizeof (struct tunnel));
char entropy_buf[2] = "\0";
if (!tmp)
return NULL;
tmp->control_seq_num = 0;
tmp->control_rec_seq_num = 0;
tmp->cLr = 0;
tmp->call_head = NULL;
tmp->next = NULL;
tmp->debug = -1;
tmp->tid = -1;
tmp->hello = NULL;
#ifndef TESTING
/* while(get_call((tmp->ourtid = rand() & 0xFFFF),0,0,0)); */
#ifdef USE_KERNEL
if (kernel_support)
tmp->ourtid = ioctl (server_socket, L2TPIOCADDTUNNEL, 0);
else
#endif
/* tmp->ourtid = rand () & 0xFFFF; */
/* get_entropy((char *)&tmp->ourtid, 2); */
get_entropy(entropy_buf, 2);
{
unsigned short *temp;
temp = (unsigned short *)entropy_buf;
tmp->ourtid = *temp & 0xFFFF;
#ifdef DEBUG_ENTROPY
log(LOG_DEBUG, "ourtid = %u, entropy_buf = %hx\n", tmp->ourtid, *temp);
#endif
}
#else
tmp->ourtid = 0x6227;
#endif
tmp->nego = 0;
tmp->count = 0;
tmp->state = 0; /* Nothing */
tmp->peer.sin_family = AF_INET;
tmp->peer.sin_port = 0;
bzero (&(tmp->peer.sin_addr), sizeof (tmp->peer.sin_addr));
tmp->sanity = -1;
tmp->qtid = -1;
tmp->ourfc = ASYNC_FRAMING | SYNC_FRAMING;
tmp->ourbc = 0;
tmp->ourtb = (((_u64) rand ()) << 32) | ((_u64) rand ());
tmp->fc = -1; /* These really need to be specified by the peer */
tmp->bc = -1; /* And we want to know if they forgot */
tmp->hostname[0] = 0;
tmp->vendor[0] = 0;
tmp->secret[0] = 0;
if (!(tmp->self = new_call (tmp)))
{
free (tmp);
return NULL;
};
tmp->ourrws = DEFAULT_RWS_SIZE;
tmp->self->ourfbit = FBIT;
tmp->lac = NULL;
tmp->lns = NULL;
tmp->chal_us.state = 0;
tmp->chal_us.secret[0] = 0;
memset (tmp->chal_us.reply, 0, MD_SIG_SIZE);
tmp->chal_us.challenge = NULL;
tmp->chal_us.chal_len = 0;
tmp->chal_them.state = 0;
tmp->chal_them.secret[0] = 0;
memset (tmp->chal_them.reply, 0, MD_SIG_SIZE);
tmp->chal_them.challenge = NULL;
tmp->chal_them.chal_len = 0;
tmp->chal_them.vector = (unsigned char *) malloc (VECTOR_SIZE);
tmp->chal_us.vector = NULL;
tmp->hbit = 0;
return tmp;
}
struct call *new_call (struct tunnel *parent)
{
unsigned char entropy_buf[2] = "\0";
struct call *tmp = malloc (sizeof (struct call));
if (!tmp)
return NULL;
tmp->tx_pkts = 0;
tmp->rx_pkts = 0;
tmp->tx_bytes = 0;
tmp->rx_bytes = 0;
tmp->zlb_xmit = NULL;
/* tmp->throttle = 0; */
/* tmp->dethrottle=NULL; */
tmp->prx = 0;
/* tmp->rbit = 0; */
tmp->msgtype = 0;
/* tmp->timeout = 0; */
tmp->data_seq_num = 0;
tmp->data_rec_seq_num = 0;
tmp->pLr = -1;
tmp->nego = 0;
tmp->debug = 0;
tmp->seq_reqd = 0;
tmp->state = 0; /* Nothing so far */
if (parent->self)
{
#ifndef TESTING
#ifdef USE_KERNEL
if (kernel_support)
tmp->ourcid =
ioctl (server_socket, L2TPIOCADDCALL, parent->ourtid << 16);
else
#endif
/* while(get_call(parent->ourtid, (tmp->ourcid = (rand() && 0xFFFF)),0,0)); */
/* FIXME: What about possibility of multiple random #'s??? */
/* tmp->ourcid = (rand () & 0xFFFF); */
get_entropy(entropy_buf, 2);
{
int *temp;
temp = (int *)entropy_buf;
tmp->ourcid = *temp & 0xFFFF;
#ifdef DEBUG_ENTROPY
l2tp_log(LOG_DEBUG, "ourcid = %u, entropy_buf = %hx\n", tmp->ourcid, *temp);
#endif
}
#else
tmp->ourcid = 0x6227;
#endif
}
else
{ l2tp_log(LOG_DEBUG, "%s: initializing ourcid to 0\n", __FUNCTION__);
tmp->ourcid=0;
}
tmp->dialed[0] = 0;
tmp->dialing[0] = 0;
tmp->subaddy[0] = 0;
tmp->physchan = -1;
tmp->serno = 0;
tmp->bearer = -1;
tmp->cid = -1;
tmp->qcid = -1;
tmp->container = parent;
/* tmp->rws = -1; */
tmp->fd = -1;
tmp->oldptyconf = malloc (sizeof (struct termios));
tmp->ptyname[0] = '\0'; /* mf, 08.04.2003: no name for pty yet */
tmp->pnu = 0;
tmp->cnu = 0;
tmp->needclose = 0;
tmp->closing = 0;
tmp->die = 0;
tmp->pppd = 0;
tmp->error = -1;
tmp->result = -1;
tmp->errormsg[0] = 0;
tmp->fbit = 0;
tmp->cid = 0;
tmp->lbit = 0;
/* Inherit LAC and LNS from parent */
tmp->lns = parent->lns;
tmp->lac = parent->lac;
tmp->addr = 0;
/* tmp->ourrws = DEFAULT_RWS_SIZE; */
/* if (tmp->ourrws >= 0)
tmp->ourfbit = FBIT;
else */
tmp->ourfbit = 0; /* initialize to 0 since we don't actually use this
value at this point anywhere in the code (I don't
think) We might just be able to remove it completely */
tmp->dial_no[0] = '\0'; /* jz: dialing number for outgoing call */
return tmp;
}
int nterfacer_line_event(struct esocket *sock, char *newline) {
struct sconnect *socket = sock->tag;
char *response, *theirnonceh = NULL, *theirivh = NULL;
unsigned char theirnonce[16], theiriv[16];
int number, reason;
switch(socket->status) {
case SS_IDLE:
if(strcasecmp(newline, ANTI_FULL_VERSION)) {
nterface_log(nrl, NL_INFO, "Protocol mismatch from %s: %s", socket->permit->hostname->content, newline);
return 1;
} else {
unsigned char challenge[32];
char ivhex[16 * 2 + 1], noncehex[16 * 2 + 1];
if(!get_entropy(challenge, 32) || !get_entropy(socket->iv, 16)) {
nterface_log(nrl, NL_ERROR, "Unable to open challenge/IV entropy bin!");
return 1;
}
int_to_hex(challenge, socket->challenge, 32);
int_to_hex(socket->iv, ivhex, 16);
memcpy(socket->response, challenge_response(socket->challenge, socket->permit->password->content), sizeof(socket->response));
socket->response[sizeof(socket->response) - 1] = '\0'; /* just in case */
socket->status = SS_VERSIONED;
if(!generate_nonce(socket->ournonce, 1)) {
nterface_log(nrl, NL_ERROR, "Unable to generate nonce!");
return 1;
}
int_to_hex(socket->ournonce, noncehex, 16);
if(esocket_write_line(sock, "%s %s %s", socket->challenge, ivhex, noncehex))
return BUF_ERROR;
return 0;
}
break;
case SS_VERSIONED:
for(response=newline;*response;response++) {
if((*response == ' ') && (*(response + 1))) {
*response = '\0';
theirivh = response + 1;
break;
}
}
if(theirivh) {
for(response=theirivh;*response;response++) {
if((*response == ' ') && (*(response + 1))) {
*response = '\0';
theirnonceh = response + 1;
break;
}
}
}
if(!theirivh || (strlen(theirivh) != 32) || !hex_to_int(theirivh, theiriv, sizeof(theiriv)) ||
!theirnonceh || (strlen(theirnonceh) != 32) || !hex_to_int(theirnonceh, theirnonce, sizeof(theirnonce))) {
nterface_log(nrl, NL_INFO, "Protocol error drop: %s", socket->permit->hostname->content);
return 1;
}
if(!memcmp(socket->ournonce, theirnonce, sizeof(theirnonce))) {
nterface_log(nrl, NL_INFO, "Bad nonce drop: %s", socket->permit->hostname->content);
return 1;
}
if(!strncasecmp(newline, socket->response, sizeof(socket->response))) {
unsigned char theirkey[32], ourkey[32];
derive_key(ourkey, socket->permit->password->content, socket->challenge, socket->ournonce, theirnonce, (unsigned char *)"SERVER", 6);
derive_key(theirkey, socket->permit->password->content, socket->response, theirnonce, socket->ournonce, (unsigned char *)"CLIENT", 6);
nterface_log(nrl, NL_INFO, "Authed: %s", socket->permit->hostname->content);
socket->status = SS_AUTHENTICATED;
switch_buffer_mode(sock, ourkey, socket->iv, theirkey, theiriv);
if(esocket_write_line(sock, "Oauth"))
return BUF_ERROR;
} else {
nterface_log(nrl, NL_INFO, "Bad CR drop: %s", socket->permit->hostname->content);
return 1;
}
break;
case SS_AUTHENTICATED:
nterface_log(nrl, NL_INFO|NL_LOG_ONLY, "L(%s): %s", socket->permit->hostname->content, newline);
reason = nterfacer_new_rline(newline, sock, &number);
if(reason) {
if(reason == RE_SOCKET_ERROR)
return BUF_ERROR;
if(reason != RE_BAD_LINE) {
if(esocket_write_line(sock, "%d,E%d,%s", number, reason, request_error(reason)))
return BUF_ERROR;
return 0;
} else {
return 1;
}
}
break;
}
return 0;
}