ByteVector MifarePlusSL3Commands_NEW::readBinaryPlain(
unsigned char blockno,
size_t len)
{
assert(len / 16 < 255);
uint8_t nb_block_to_read = static_cast<uint8_t>(len / 16);
/*
ByteVector mac = {1, 2, 3, 4, 5, 6, 7 , 8};
ByteVector cmd{0x34, blockno, 0x00, nb_block_to_read};
cmd.insert(cmd.end(), mac.begin(), mac.end());*/
assert(auth_);
ByteVector data(16, 'a');
data = {0x32, 0x14, 0xA5, 0xF4, 0xDE, 0x18, 0xAE, 0xC8, 0xDA, 0x6F,
0x50, 0x33, 0x32, 0xB7, 0x10, 0xD7};
// data = {0x02, 0xBB, 0x2A, 0x18, 0xBA, 0x7C, 0x4B, 0x54, 0xFC, 0x9F,
// 0x8C, 0xAE, 0x37, 0x7F, 0x5C, 0x1A};
//data = auth_->cipherWriteData(data);
LOG(DEBUGS) << "Data encryp: " << data;
ByteVector cmd = {0xA3, blockno, 0x00};
cmd.insert(cmd.end(), data.begin(), data.end());
auto mac = auth_->computeWriteMac(0xA3, blockno, data);
//auto mac = GetMacOnCommand(cmd, auth_->trans_id_, auth_->deriveKMac());
LOG(DEBUGS) << "Mac = " << mac;
cmd.insert(cmd.end(), mac.begin(), mac.end());
auto ret = getReaderCardAdapter()->sendCommand(cmd);
LOG(DEBUGS) << "Ret from plain read" << ret;
return ret;
}
void BufferReader::SetData(uchar* thePtr, int theCount)
{
mData.clear();
mData.reserve(theCount);
mData.insert(mData.begin(), thePtr, thePtr + theCount);
mDataBitSize = mData.size() * 8;
}
bool receive_request_test(ByteVector &request, int attempt)
{
String data;
switch (attempt) {
case 0:
data += "GET / HTTP/1.1\r\n";
data += "Accept: */*\r\n";
break;
case 1:
break;
case 2:
data += "User-Agent: Test\r\n";
data += "Host";
break;
case 3:
data += ": 127.0.0.1\r\n";
data += "Content-Length: 4\r\n";
break;
case 4:
data += "\r\n";
break;
case 5:
break;
case 6:
data += "12";
break;
case 7:
data += "34";
break;
default:
return false;
}
request.insert(request.end(), data.begin(), data.end());
return true;
}
bool CHttpServer::receive_request(ByteVector &request)
{
if (verbose) RAWTRACE("Receiving request...");
ByteVector r;
char buf[BUF_SIZE];
int attempts = 0;
for(;;) {
if (verbose) RAWTRACE("Read portion of data from socket...");
int n = recv(m_sock, &buf[0], sizeof(buf), 0);
//RAWTRACE1("RECV: %d", n);
if (n == -1) {
int e = RHO_NET_ERROR_CODE;
if (verbose) RAWTRACE1("RECV ERROR: %d", e);
#if !defined(WINDOWS_PLATFORM)
if (e == EINTR)
continue;
#else
if (e == WSAEINTR)
continue;
#endif
#if defined(OS_WP8) || (defined(RHODES_QT_PLATFORM) && defined(OS_WINDOWS_DESKTOP)) || defined(OS_WINCE)
if (e == EAGAIN || e == WSAEWOULDBLOCK) {
#else
if (e == EAGAIN) {
#endif
if (!r.empty())
break;
if(++attempts > (HTTP_EAGAIN_TIMEOUT*10))
{
if (verbose) RAWLOG_ERROR("Error when receiving data from socket. Client does not send data for " HTTP_EAGAIN_TIMEOUT_STR " sec. Cancel recieve.");
return false;
}
fd_set fds;
FD_ZERO(&fds);
FD_SET(m_sock, &fds);
timeval tv = {0};
tv.tv_usec = 100000;//100 MS
select(m_sock + 1, &fds, 0, 0, &tv);
continue;
}
if (verbose) RAWLOG_ERROR1("Error when receiving data from socket: %d", e);
return false;
}
if (n == 0) {
if(!r.empty()) {
if (verbose) RAWTRACE("Client closed connection gracefully");
break;
} else {
if (verbose) RAWLOG_ERROR("Connection gracefully closed before we receive any data");
return false;
}
} else {
if (verbose) RAWTRACE1("Actually read %d bytes", n);
r.insert(r.end(), &buf[0], &buf[0] + n);
}
}
if (!r.empty()) {
request.insert(request.end(), r.begin(), r.end());
if ( !rho_conf_getBool("log_skip_post") ) {
String strRequest(request.begin(),request.end());
if (verbose) RAWTRACE1("Received request:\n%s", strRequest.c_str());
}
}
return true;
}
bool CHttpServer::send_response_impl(String const &data, bool continuation)
{
#ifdef OS_MACOSX
if ( m_localResponseWriter != 0 ) {
m_localResponseWriter->writeResponse( data );
return true;
}
#endif
if (verbose) {
if (continuation)
if (verbose) RAWTRACE("Send continuation data...");
else
if (verbose) RAWTRACE("Sending response...");
}
// First of all, make socket blocking
#if defined(WINDOWS_PLATFORM)
unsigned long optval = 0;
if(::ioctlsocket(m_sock, FIONBIO, &optval) == SOCKET_ERROR) {
RAWLOG_ERROR1("Can not set blocking socket mode: %d", RHO_NET_ERROR_CODE);
return false;
}
#else
int flags = fcntl(m_sock, F_GETFL);
if (flags == -1) {
if (verbose) RAWLOG_ERROR1("Can not get current socket mode: %d", errno);
return false;
}
if (fcntl(m_sock, F_SETFL, flags & ~O_NONBLOCK) == -1) {
if (verbose) RAWLOG_ERROR1("Can not set blocking socket mode: %d", errno);
return false;
}
#endif
size_t pos = 0;
for(; pos < data.size();) {
int n = send(m_sock, data.c_str() + pos, data.size() - pos, 0);
if (n == -1) {
int e = RHO_NET_ERROR_CODE;
#if !defined(WINDOWS_PLATFORM)
if (e == EINTR)
continue;
#endif
if (verbose) RAWLOG_ERROR1("Can not send response data: %d", e);
return false;
}
if (n == 0)
break;
pos += n;
}
//String dbg_response = response.size() > 100 ? response.substr(0, 100) : response;
//RAWTRACE2("Sent response:\n%s%s", dbg_response.c_str(), response.size() > 100 ? "..." : " ");
if (continuation) {
if (verbose) RAWTRACE1("Sent response body: %d bytes", data.size());
}
else if ( !rho_conf_getBool("log_skip_post") ) {
if (verbose) RAWTRACE1("Sent response (only headers displayed):\n%s", data.c_str());
}
return true;
}
bool CHttpServer::send_response(String const &response, bool redirect)
{
#ifdef OS_ANDROID
if (redirect) {
CAutoPtr<IRhoThreadImpl> ptrThread = rho_get_RhoClassFactory()->createThreadImpl();
ptrThread->sleep(20);
}
#endif
return send_response_impl(response, false);
}
String CHttpServer::create_response(String const &reason)
{
return create_response(reason, "");
}
String CHttpServer::create_response(String const &reason, HeaderList const &headers)
{
return create_response(reason, headers, "");
}
String CHttpServer::create_response(String const &reason, String const &body)
{
return create_response(reason, HeaderList(), body);
}
String CHttpServer::create_response(String const &reason, HeaderList const &hdrs, String const &body)
{
String response = "HTTP/1.1 ";
response += reason;
response += "\r\n";
char buf[50];
snprintf(buf, sizeof(buf), "%d", m_port);
HeaderList headers;
headers.push_back(Header("Host", String("127.0.0.1:") + buf));
headers.push_back(Header("Connection", "close"));
headers.push_back(HttpHeader("Access-Control-Allow-Origin", "*"));
std::copy(hdrs.begin(), hdrs.end(), std::back_inserter(headers));
for(HeaderList::const_iterator it = headers.begin(), lim = headers.end();
it != lim; ++it) {
response += it->name;
response += ": ";
response += it->value;
response += "\r\n";
}
response += "\r\n";
response += body;
return response;
}
/**
* Runs the operation.
*/
void ReadWriteThread::run()
throw ()
{
try {
if (m_card.getType() != MemoryCard::TMemoryCard) {
m_exception = new ReadWriteException(QObject::tr("There's no memory card in your "
"reader.\nUse the test function in the configuration\ndialog to set up your "
"reader properly."), ReadWriteException::CSmartcardError);
return;
}
if (m_write && !m_pin.isNull()) {
// try to unlock
qDebug() << CURRENT_FUNCTION << "Trying to unlock the card ...";
m_card.verify(m_pin);
}
if (!m_card.selectFile()) {
m_exception = new ReadWriteException(QObject::tr("<qt>It was not possible to select the "
"file on the smartcard</qt>"), ReadWriteException::CSmartcardError);
return;
}
if (m_write) {
// write the random number
ByteVector byteVector(1);
byteVector[0] = m_randomNumber;
qDebug() << CURRENT_FUNCTION << "Writing random =" << byteVector[0];
m_card.write(0, byteVector);
// write the password hash and include a length information
ByteVector pwHash = PasswordHash::generateHash(m_password);
pwHash.insert(pwHash.begin(), pwHash.size());
m_card.write(1, pwHash);
qDebug() << CURRENT_FUNCTION << "Password hash length = " << (pwHash.size()-1);
// then write the number of bytes
int numberOfBytes = m_bytes.size();
byteVector.resize(3);
byteVector[0] = (numberOfBytes & 0xFF00) >> 8;
byteVector[1] = numberOfBytes & 0xFF;
byteVector[2] = 0; // fillbyte
m_card.write(PasswordHash::MAX_HASH_LENGTH+2, byteVector);
// and finally write the data
m_card.write(PasswordHash::MAX_HASH_LENGTH+5, m_bytes);
} else {
// read the random number
if (m_card.read(0, 1)[0] != m_randomNumber) {
m_exception = new ReadWriteException(QObject::tr("You inserted the wrong smartcard!"),
ReadWriteException::CSmartcardError);
return;
}
qDebug() << CURRENT_FUNCTION << "Read randomNumber =" << m_randomNumber;
// read the password hash, check the password and throw a exception if necessary
unsigned char len = m_card.read(1, 1)[0];
ByteVector pwHash = m_card.read(2, len);
qDebug() << CURRENT_FUNCTION << "Password hash length =" << len;
if (!PasswordHash::isCorrect(m_password, pwHash)) {
m_exception = new ReadWriteException(QObject::tr("The given password was wrong."),
ReadWriteException::CWrongPassword);
return;
}
// read the number
ByteVector vec = m_card.read(PasswordHash::MAX_HASH_LENGTH + 2, 2);
int numberOfBytes = (vec[0] << 8) + (vec[1]);
qDebug() << CURRENT_FUNCTION << "Read numberOfBytes =" << numberOfBytes;
Q_ASSERT(numberOfBytes >= 0);
// read the bytes
m_bytes = m_card.read(PasswordHash::MAX_HASH_LENGTH+5, numberOfBytes);
}
} catch (const CardException& e) {
