size_t CBC_Decryption::process(uint8_t buf[], size_t sz)
{
const size_t BS = cipher().block_size();
BOTAN_ASSERT(sz % BS == 0, "Input is full blocks");
size_t blocks = sz / BS;
while(blocks)
{
const size_t to_proc = std::min(BS * blocks, m_tempbuf.size());
cipher().decrypt_n(buf, m_tempbuf.data(), to_proc / BS);
xor_buf(m_tempbuf.data(), state_ptr(), BS);
xor_buf(&m_tempbuf[BS], buf, to_proc - BS);
copy_mem(state_ptr(), buf + (to_proc - BS), BS);
copy_mem(buf, m_tempbuf.data(), to_proc);
buf += to_proc;
blocks -= to_proc / BS;
}
return sz;
}
void AlphanumericState::next_state(LexingAutomation &automation, SymbolTypes symbol_type)
{
switch (symbol_type)
{
case kUnderscore:
case kLetter:
case kDigit:
break;
case kOperationSymbol:
{
automation.set_result(handle_alphanumeric(automation.get_buffer_prefix(), automation.line(), automation.column()));
automation.set_buffer_to_last_char();
automation.set_state(state_ptr(new OperationState()));
}
break;
case kSeparator:
{
automation.set_result(handle_alphanumeric(automation.get_buffer_prefix(), automation.line(), automation.column()));
string buffer = automation.buffer();
char lexeme_symbol = buffer[buffer.length() - 1];
Lexeme result = handle_separator(lexeme_symbol, automation.line(), automation.column());
automation.set_result(result);
automation.clear_buffer();
automation.set_state(state_ptr(new EmptyState()));
}
break;
case kLinefeed:
{
automation.set_result(handle_alphanumeric(automation.get_buffer_prefix(), automation.line(), automation.column()));
automation.set_result(end_of_line(automation.line(), automation.column()));
automation.clear_buffer();
automation.set_state(state_ptr(new EmptyState()));
}
break;
case kWhitespace:
{
automation.set_result(handle_alphanumeric(automation.get_buffer_prefix(), automation.line(), automation.column()));
automation.clear_buffer();
automation.set_state(state_ptr(new EmptyState()));
}
break;
case kHashSymbol:
{
automation.set_result(handle_alphanumeric(automation.get_buffer_prefix(), automation.line(),automation.column()));
automation.set_state(state_ptr(new CommentState()));
}
break;
default:
ErrorHandler::report_syntax_error(automation.line());
automation.set_state(state_ptr(new ErrorState()));
break;
}
}
void CTS_Decryption::finish(secure_vector<uint8_t>& buffer, size_t offset)
{
BOTAN_ASSERT(buffer.size() >= offset, "Offset is sane");
const size_t sz = buffer.size() - offset;
uint8_t* buf = buffer.data() + offset;
const size_t BS = cipher().block_size();
if(sz < BS + 1)
throw Encoding_Error(name() + ": insufficient data to decrypt");
if(sz % BS == 0)
{
// swap last two blocks
for(size_t i = 0; i != BS; ++i)
std::swap(buffer[buffer.size()-BS+i], buffer[buffer.size()-2*BS+i]);
update(buffer, offset);
}
else
{
const size_t full_blocks = ((sz / BS) - 1) * BS;
const size_t final_bytes = sz - full_blocks;
BOTAN_ASSERT(final_bytes > BS && final_bytes < 2*BS, "Left over size in expected range");
secure_vector<uint8_t> last(buf + full_blocks, buf + full_blocks + final_bytes);
buffer.resize(full_blocks + offset);
update(buffer, offset);
cipher().decrypt(last.data());
xor_buf(last.data(), &last[BS], final_bytes - BS);
for(size_t i = 0; i != final_bytes - BS; ++i)
std::swap(last[i], last[i + BS]);
cipher().decrypt(last.data());
xor_buf(last.data(), state_ptr(), BS);
buffer += last;
}
}
void EmptyState::next_state(LexingAutomation& automation, SymbolTypes symbol_type)
{
switch (symbol_type)
{
case kLetter:
automation.set_state(state_ptr(new AlphanumericState()));
break;
case kDigit:
automation.set_state(state_ptr(new NumericState()));
break;
case kOperationSymbol:
automation.set_state(state_ptr(new OperationState()));
break;
case kSeparator:
{
string buffer = automation.buffer();
char lexeme_symbol = buffer[buffer.length() - 1];
Lexeme result = handle_separator(lexeme_symbol, automation.line(), automation.column());
automation.set_result(result);
automation.clear_buffer();
}
break;
case kLinefeed:
automation.set_result(end_of_line(automation.line(), automation.column()));
automation.clear_buffer();
break;
case kWhitespace:
if (automation.buffer().length() != 1)
automation.set_state(state_ptr(new ErrorState()));
else
automation.clear_buffer();
break;
case kHashSymbol:
automation.set_state(state_ptr(new CommentState()));
break;
default:
ErrorHandler::report_syntax_error(automation.line());
automation.set_state(state_ptr(new ErrorState()));
break;
}
}
void Experiment::reset(){
ContainerState::reset();
// TODO: is implicit cast kosher?
weak_ptr<State> state_ptr(current_protocol);
setCurrentState(state_ptr);
if(stimulus_display != NULL){
stimulus_display->clearDisplay();
}
//variable_registry->reset();
// delete variable_registry;
// variable_registry = new VariableRegistry();
// initializeStandardVariables(variable_registry);
// global_variable_registry = variable_registry;
// issue an event that the experiment has stopped
global_outgoing_event_buffer->putEvent(SystemEventFactory::currentExperimentState());
}
size_t CBC_Encryption::process(uint8_t buf[], size_t sz)
{
const size_t BS = cipher().block_size();
BOTAN_ASSERT(sz % BS == 0, "CBC input is full blocks");
const size_t blocks = sz / BS;
const uint8_t* prev_block = state_ptr();
if(blocks)
{
for(size_t i = 0; i != blocks; ++i)
{
xor_buf(&buf[BS*i], prev_block, BS);
cipher().encrypt(&buf[BS*i]);
prev_block = &buf[BS*i];
}
state().assign(&buf[BS*(blocks-1)], &buf[BS*blocks]);
}
return sz;
}
void QDnsLookupRunnable::query(const int requestType, const QByteArray &requestName, const QHostAddress &nameserver, QDnsLookupReply *reply)
{
// Load dn_expand, res_ninit and res_nquery on demand.
static QBasicAtomicInt triedResolve = Q_BASIC_ATOMIC_INITIALIZER(false);
if (!triedResolve.loadAcquire()) {
QMutexLocker locker(QMutexPool::globalInstanceGet(&local_res_ninit));
if (!triedResolve.load()) {
resolveLibrary();
triedResolve.storeRelease(true);
}
}
// If dn_expand, res_ninit or res_nquery is missing, fail.
if (!local_dn_expand || !local_res_nclose || !local_res_ninit || !local_res_nquery) {
reply->error = QDnsLookup::ResolverError;
reply->errorString = tr("Resolver functions not found");
return;
}
// Initialize state.
struct __res_state state;
memset(&state, 0, sizeof(state));
if (local_res_ninit(&state) < 0) {
reply->error = QDnsLookup::ResolverError;
reply->errorString = tr("Resolver initialization failed");
return;
}
//Check if a nameserver was set. If so, use it
if (!nameserver.isNull()) {
if (nameserver.protocol() == QAbstractSocket::IPv4Protocol) {
state.nsaddr_list[0].sin_addr.s_addr = htonl(nameserver.toIPv4Address());
state.nscount = 1;
} else if (nameserver.protocol() == QAbstractSocket::IPv6Protocol) {
#if defined(Q_OS_LINUX)
struct sockaddr_in6 *ns;
ns = state._u._ext.nsaddrs[0];
// nsaddrs will be NULL if no nameserver is set in /etc/resolv.conf
if (!ns) {
// Memory allocated here will be free'd in res_close() as we
// have done res_init() above.
ns = (struct sockaddr_in6*) calloc(1, sizeof(struct sockaddr_in6));
Q_CHECK_PTR(ns);
state._u._ext.nsaddrs[0] = ns;
}
// Set nsmap[] to indicate that nsaddrs[0] is an IPv6 address
// See: https://sourceware.org/ml/libc-hacker/2002-05/msg00035.html
state._u._ext.nsmap[0] = MAXNS + 1;
state._u._ext.nscount6 = 1;
ns->sin6_family = AF_INET6;
ns->sin6_port = htons(53);
Q_IPV6ADDR ipv6Address = nameserver.toIPv6Address();
for (int i=0; i<16; i++) {
ns->sin6_addr.s6_addr[i] = ipv6Address[i];
}
#else
qWarning() << Q_FUNC_INFO << "IPv6 addresses for nameservers is currently not supported";
reply->error = QDnsLookup::ResolverError;
reply->errorString = tr("IPv6 addresses for nameservers is currently not supported");
return;
#endif
}
}
#ifdef QDNSLOOKUP_DEBUG
state.options |= RES_DEBUG;
#endif
QScopedPointer<struct __res_state, QDnsLookupStateDeleter> state_ptr(&state);
// Perform DNS query.
unsigned char response[PACKETSZ];
memset(response, 0, sizeof(response));
const int responseLength = local_res_nquery(&state, requestName, C_IN, requestType, response, sizeof(response));
// Check the response header.
HEADER *header = (HEADER*)response;
const int answerCount = ntohs(header->ancount);
switch (header->rcode) {
case NOERROR:
break;
case FORMERR:
reply->error = QDnsLookup::InvalidRequestError;
reply->errorString = tr("Server could not process query");
return;
case SERVFAIL:
reply->error = QDnsLookup::ServerFailureError;
reply->errorString = tr("Server failure");
return;
case NXDOMAIN:
reply->error = QDnsLookup::NotFoundError;
reply->errorString = tr("Non existent domain");
return;
case REFUSED:
reply->error = QDnsLookup::ServerRefusedError;
reply->errorString = tr("Server refused to answer");
return;
default:
reply->error = QDnsLookup::InvalidReplyError;
reply->errorString = tr("Invalid reply received");
return;
}
// Check the reply is valid.
if (responseLength < int(sizeof(HEADER))) {
reply->error = QDnsLookup::InvalidReplyError;
reply->errorString = tr("Invalid reply received");
return;
}
// Skip the query host, type (2 bytes) and class (2 bytes).
char host[PACKETSZ], answer[PACKETSZ];
unsigned char *p = response + sizeof(HEADER);
int status = local_dn_expand(response, response + responseLength, p, host, sizeof(host));
if (status < 0) {
reply->error = QDnsLookup::InvalidReplyError;
reply->errorString = tr("Could not expand domain name");
return;
}
p += status + 4;
// Extract results.
int answerIndex = 0;
while ((p < response + responseLength) && (answerIndex < answerCount)) {
status = local_dn_expand(response, response + responseLength, p, host, sizeof(host));
if (status < 0) {
reply->error = QDnsLookup::InvalidReplyError;
reply->errorString = tr("Could not expand domain name");
return;
}
const QString name = QUrl::fromAce(host);
p += status;
const quint16 type = (p[0] << 8) | p[1];
p += 2; // RR type
p += 2; // RR class
const quint32 ttl = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
p += 4;
const quint16 size = (p[0] << 8) | p[1];
p += 2;
if (type == QDnsLookup::A) {
if (size != 4) {
reply->error = QDnsLookup::InvalidReplyError;
reply->errorString = tr("Invalid IPv4 address record");
return;
}
const quint32 addr = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
QDnsHostAddressRecord record;
record.d->name = name;
record.d->timeToLive = ttl;
record.d->value = QHostAddress(addr);
reply->hostAddressRecords.append(record);
} else if (type == QDnsLookup::AAAA) {
if (size != 16) {
reply->error = QDnsLookup::InvalidReplyError;
reply->errorString = tr("Invalid IPv6 address record");
return;
}
QDnsHostAddressRecord record;
record.d->name = name;
record.d->timeToLive = ttl;
record.d->value = QHostAddress(p);
reply->hostAddressRecords.append(record);
} else if (type == QDnsLookup::CNAME) {
status = local_dn_expand(response, response + responseLength, p, answer, sizeof(answer));
if (status < 0) {
reply->error = QDnsLookup::InvalidReplyError;
reply->errorString = tr("Invalid canonical name record");
return;
}
QDnsDomainNameRecord record;
record.d->name = name;
record.d->timeToLive = ttl;
record.d->value = QUrl::fromAce(answer);
reply->canonicalNameRecords.append(record);
} else if (type == QDnsLookup::NS) {
status = local_dn_expand(response, response + responseLength, p, answer, sizeof(answer));
if (status < 0) {
reply->error = QDnsLookup::InvalidReplyError;
reply->errorString = tr("Invalid name server record");
return;
}
QDnsDomainNameRecord record;
record.d->name = name;
record.d->timeToLive = ttl;
record.d->value = QUrl::fromAce(answer);
reply->nameServerRecords.append(record);
} else if (type == QDnsLookup::PTR) {
status = local_dn_expand(response, response + responseLength, p, answer, sizeof(answer));
if (status < 0) {
reply->error = QDnsLookup::InvalidReplyError;
reply->errorString = tr("Invalid pointer record");
return;
}
QDnsDomainNameRecord record;
record.d->name = name;
record.d->timeToLive = ttl;
record.d->value = QUrl::fromAce(answer);
reply->pointerRecords.append(record);
} else if (type == QDnsLookup::MX) {
const quint16 preference = (p[0] << 8) | p[1];
status = local_dn_expand(response, response + responseLength, p + 2, answer, sizeof(answer));
if (status < 0) {
reply->error = QDnsLookup::InvalidReplyError;
reply->errorString = tr("Invalid mail exchange record");
return;
}
QDnsMailExchangeRecord record;
record.d->exchange = QUrl::fromAce(answer);
record.d->name = name;
record.d->preference = preference;
record.d->timeToLive = ttl;
reply->mailExchangeRecords.append(record);
} else if (type == QDnsLookup::SRV) {
const quint16 priority = (p[0] << 8) | p[1];
const quint16 weight = (p[2] << 8) | p[3];
const quint16 port = (p[4] << 8) | p[5];
status = local_dn_expand(response, response + responseLength, p + 6, answer, sizeof(answer));
if (status < 0) {
reply->error = QDnsLookup::InvalidReplyError;
reply->errorString = tr("Invalid service record");
return;
}
QDnsServiceRecord record;
record.d->name = name;
record.d->target = QUrl::fromAce(answer);
record.d->port = port;
record.d->priority = priority;
record.d->timeToLive = ttl;
record.d->weight = weight;
reply->serviceRecords.append(record);
} else if (type == QDnsLookup::TXT) {
unsigned char *txt = p;
QDnsTextRecord record;
record.d->name = name;
record.d->timeToLive = ttl;
while (txt < p + size) {
const unsigned char length = *txt;
txt++;
if (txt + length > p + size) {
reply->error = QDnsLookup::InvalidReplyError;
reply->errorString = tr("Invalid text record");
return;
}
record.d->values << QByteArray((char*)txt, length);
txt += length;
}
reply->textRecords.append(record);
}
p += size;
answerIndex++;
}
}
void wsplayer_t::init_states()
{
current_state=0;
if(states.empty())states.push_back(state_ptr(new state_t(*this)));
get_state().init_zero();
}
void wsplayer_t::increase_state()
{
++current_state;
if(current_state+1>states.size())states.push_back(state_ptr(new state_t(*this)));
states[current_state]->state_from(*states[current_state-1]);
}
