Monthly Archives: May 2018

How Smart Dust Could Be Used To Monitor Human Thought

How Smart Dust Could Be Used To Monitor Human Thought

A few years ago a team of researchers from Brown University made headlines after they successfully demonstrated how a paralyzed woman who had lost the use of her arms and legs could control a robotic arm using her brainwaves. In a video, Cathy Hutchinson imagines drinking a cup of coffee, and the robotic arm brings the cup to her lips.

The scene is amazing, but also a little disturbing. Hutchinson is connected to the robotic arm through a rod-like “pedestal” driven into her skull. At one end of the pedestal, a bundle of gold wires is attached to a tiny array of microelectrodes that is implanted in the primary motor cortex of Hutchison’s brain. This sensor, which is about the size of a baby aspirin, records her neural activity. At the other end of the pedestal is an external cable that transmits neural data to a nearby computer, which translates the signals into code that guides the robotic arm.

This method, known as BrainGate, pretty much defined state-of-the-art brain-computer interfaces at the end of the last decade. If the idea of a rod-through-the-head computer interface makes you cringe, you are not alone.

For some time, a small team of researchers at UC Berkeley has been working on plans for a less invasive, wireless monitoring system. Earlier this month, they released a draft paper: “Neural Dust: An Ultrasonic, Low Power Solution for Chronic Brain-Machine Interfaces.”

Dongjin Seo, a graduate student in UC Berkeley’s electrical engineering and computer science department, authored the paper under the supervision of senior faculty members, including Michel Maharbiz who has famously created cyborg beetles for the US Defense Department.

Seo said the researchers’ goal is to build an implantable system that is ultra-miniature, extremely compliant, and scalable to be viable for a lifetime, for brain-machine interfaces. “With neural dust, due to its extreme scalability, this framework can be applied for Obama’s BRAIN initiative, which necessitates large-scale, parallel, and real-time monitoring of neurons,” Seo explained.

The Berkeley researchers propose to sprinkle the brain with tiny, dust-sized, wireless sensors. This would reduce the risk of infection from wiring up scores of sensors placed throughout the brain and limit the trauma to one initial operation. During that operation, the skull would be opened, and sensors would be inserted into the brain. At the same time a separate transceiver would be placed directly under the skull but above the brain. The transceiver would communicate with the sensors via ultrasound.

Another battery-powered transceiver outside the skull would receive data transmissions from the chip inside the skull and supply wireless power to it.  As the paper notes, this type of power transfer is already used in a variety of medical applications, including cochlear implants. Seo said the amount of power being proposed is within FDA and IEEE guidelines.

The idea of neural dust immediately sparked the imagination of futurists after the paper was published on arXiv.org on July 8. “The brilliance of this system is that it could potentially allow scientists to see what’s going on with thousands, tens of thousands, or even hundreds of thousands of neurons inside the brain at once,” wrote Ramez Naam, a senior associate at the Foresight Institute and author of “More Than Human: Embracing the promise of biological enhancement.”

But would neural dust have practical use for the growing industry of mind-controlled computer games and brain training apps? Jon Cowan, founder ofNeuroTek, is dubious. NeuroTek’s Peak Achievement Training has been used at the U.S. Olympic Training Center in Colorado Springs, as well as at other Olympic centers from China to Norway.

“[Neural dust] doesn’t have much practical promise because of the surgery it would require,” Cowan said. “I don’t think they’ll find too many people that would volunteer for it.” Cowan noted existing ways for measuring brainwaves that rely on external sensors may be crude, but they’re effective enough for today’s applications.

“We really believe this is a practical system and, more importantly, we think this is potentially a powerful framework for achieving what Obama has announced,” Seo said. Still, he pointed out that the paper is a draft. “It’s a concept paper,” he said. “It’s a theoretical study of what we think is possible in the realm of neural recording.”

By publishing the paper on arXiv.org, an online collection of preprints of scientific work, the team is hoping to spur involvement and feedback from scientists in different fields. Lots of challenges remain to be overcome before neural dust will be ready for live testing.

Easy Solutions Helps Fight Mobile Banking Fraud with Detect Safe Browsing (DSB) 4.0, Now Available for iPhone and Android

Easy Solutions Helps Fight Mobile Banking Fraud with Detect Safe Browsing (DSB) 4.0, Now Available for iPhone and Android

Easy Solutions, the Total Fraud Protection® company, today released Detect Safe Browsing (DSB) version 4.0. With DSB 4.0, financial institution can provide an important additional layer of fraud prevention to the end-user, to better protect against malware and other sophisticated threats such as, pharming, man-in-the-middle (MITM) and man-in-the browser (MITB) attacks. With DSB 4.0, Easy Solutions now extends this support to the two most popular mobile platforms: Android and iOS, ensuring that over 90%1 of mobile users can securely access their mobile banking accounts.

The APWG recently reported over 1.3 million confirmed-malicious files for Android alone2, making mobile malware one of the fastest growing classes of threats.

“Mobile banking has become the preferred method for many consumers to conduct their online banking. Unfortunately for financial institutions, some of the most insidious and difficult-to-detect malware is now being targeted at the mobile end-point,” said Daniel Ingevaldson, CTO of Easy Solutions. “With Detect Safe Browsing now available for iPhone and Android devices, financial institutions will be able to provide their customers with a simple and unobtrusive way to secure their mobile banking experience.”

DSB is a critical component of Easy Solutions’ Total Fraud Protection platform, which provides comprehensive fraud protection across all channels, and extended to the end-user. By combining cross-channel risk-scoring, transaction anomaly detection, multi-factor authentication, secure browsing, and detection and take-down services, Easy Solutions blocks criminals at all three phases of the fraud lifecycle – planning, launching, and cashing – while ensuring that authorized users can conduct business.

DSB 4.0 from Easy Solutions provides visibility and real-time intelligence of the threats impacting consumers. Based on a proprietary cross validation technology that prevents re-direction to fraudulent websites, DSB 4.0 includes some of the following capabilities:

  • Secure Mobile Browsing with the DSB App: The free DSB app, now available for both iOS and Android devices, gives customers a simple way to protect bank transactions performed on their mobile device or tablet
  • Accelerated Disinfection: DSB enables customers to quickly deploy on-demand cleanup procedures for malware related advanced persistent threats (APTs), enabling financial institutions to mitigate zero-day and targeted attacks.
  • Active Phishing Protection: DSB provides enhanced phishing protection based on Detect Monitoring Services’ (DMS) black list. Since DMS detects phishing attacks in early stages, DSB users are protected from the very latest phishing scams, minimizing their exposure to fraud.
  • Proactive, Real-time Malware Protection: DSB employs proprietary cross-validation technology that detects DNS poisoning and ensures that the end user can connect to the protected site. When an active redirection is detected, DSB stops the fraudulent connection.

ABOUT EASY SOLUTIONS

Easy Solutions delivers Total Fraud Protection® to over 100 clients, with over 32 million end users. The company’s products protect against phishing, pharming, malware, Man-in-the-Middle and Man-in-the-Browser attacks, and deliver multifactor authentication and transaction anomaly detection. For more information, visit http://www.easysol.net, or follow us on Twitter @goeasysol.

Lenovo ThinkPad T440s, Ultrabook 14 Inci Full HD Artikel Baru CPU Intel Haswell & baterei 3-Cell Ganda

Lenovo ThinkPad T440s, Ultrabook 14 Inci Full HD Artikel Baru CPU Intel Haswell & baterei 3-Cell Ganda

The presence of an Intel Core 4th generation Intel Haswell known as it turns out has brought blessing for Lenovo to immediately roll out the latest models of ultrabook and ThinkPad T440S Lenovo ThinkPad claimed to be the first to adopt the power of the processor.

Unlike most existing ThinkPad notebooks, Lenovo ThinkPad T440S This is more aimed at business users. Especially with premium features that it has, making super thin and light laptop is equipped with resilient chasing bandage made ​​of carbon fiber and magnesium, water resistant keyboard, touchpad with support for 5-point click and gesture, and a pointer nub in the middle of the keyboard , as well as dual battery setup that allows you menggonta-replace (remove plug) one batereinya without first turning off the existing system.

Lenovo ThinkPad T440s is itself supplied by feature 14-inch LCD screen with a resolution of 1600 × 900 option pixels or 1920 × 1080 pixels (HD + / FHD). As for users who want greater convenience in operation there, Lenovo also provides a choice of touch screen and support for NFC wireless technology.

Not only that, the article is a laptop with a 0.83-inch thick and weighs 1.5 kg has also been equipped by Mini DisplayPort and VGA, 3 USB 3.0 ports, 4-in-1 SD card reader, combo jack, and a smart card reader , HD anti-noise microphone dual stereo speakers with support Dolby ® HomeTheater ® v4 and two standard 3-cell battery that could have staying power usage up to 6 hours.

While about availability and price, unfortunately not yet known specific info related to it so far.

Data Management Android WiFi File Transfer

Data Management Android WiFi File Transfer

Cruising Through the Content Browser Using Wireless Smartphone

Transfer content from your PC to the Android-based smartphone is easy. Several methods can be used for it. You have a choice of using a regular cable connection represented USB port or wireless connection represented by bluetooth and WiFi. If you have a router that is connected to the PC and smartphone in one network, it can use wireless connections to share data without bothered by wires.

d4-436-wifiWiFi File File Transfer offers ease of operation. You pass enough alone installation on a smartphone. When run, the application will detect your internet protocol (IP) on the computer and then instantly displays the IP address of the smartphone. Later on smartphone app will display an IP address that is automatically configured. To connect the smartphone to the computer, you just enter the IP address displayed on the smartphone via the browser and automatically you can directly access the entire contents of the smartphone via browser.

Automated storage media on a smartphone will instantly appear in the browser like a file manager in Windows. You stay down all the existing content on the memory card and can perform various commands such as download, delete, copy, or rename. You can also combine all or part of existing content by performing compression in a ZIP format and make the content. The application also displays a special shortcut to a content-based image file directory with the name of the Media Gallery.

Integrating C++ with QML

Integrating C++ with QML

Introduction

Qt Quick’s QML language makes it easy to do many things, especially fancy animated user interfaces. However, some things either can’t be done or are not suitable for implementing in QML, such as:

  1. Getting access to functionality outside of the QML/JavaScript environment.
  2. Implementing performance critical functions where native code is desired for efficiency.
  3. Large and/or complex non-declarative code that would be tedious to implement in JavaScript.

As we’ll see, Qt makes it quite easy to expose C++ code to QML. In this blog post I will show an example of doing this with a small but functional application.

The example is written for Qt 5 and uses the Qt Quick Components so you will need at least Qt version 5.1.0 to run it.

Overview

To expose a C++ type having properties, methods, signals, and/or slots to the QML environment, the basic steps are:

  1. Define a new class derived from QObject.
  2. Put the Q_OBJECT macro in the class declaration to support signals and slots and other services of the Qt meta-object system.
  3. Declare any properties using the Q_PROPERTY macro.
  4. Call qmlRegisterType() in your C++ main program to register the type with the Qt Quick engine.

For all the details I refer you to the Qt documentation section Exposing Attributes of C++ Types to QML and the Writing QML Extensions with C++ tutorial.

Ssh Key Generator

For our code example, we want a small application that will generate ssh public/private key pairs using a GUI. It will present the user with controls for the appropriate options and then run the program ssh-keygen to generate the key pair.

I implemented the user interface using the new Qt Quick Controls since it was intended as a desktop application with a desktop look and feel. I initially developed the UX entirely by running the qmlscene program directly on the QML source.

The UI prompts the user for the key type, the file name of the private key to generate and an optional pass phrase, which needs to be confirmed.

The C++ Class

Now that have the UI, we will want to implement the back end functionality. You can’t invoke an external program directly from QML so we have to write it in C++ (which is the whole point of this example application).

First, we define a class that encapsulates the key generation functionality. It will be exposed as a new class KeyGenerator in QML. This is done in the header file KeyGenerator.h below.

#ifndef KEYGENERATOR_H
#define KEYGENERATOR_H

#include <QObject>
#include <QString>
#include <QStringList>

// Simple QML object to generate SSH key pairs by calling ssh-keygen.

class KeyGenerator : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString type READ type WRITE setType NOTIFY typeChanged)
    Q_PROPERTY(QStringList types READ types NOTIFY typesChanged)
    Q_PROPERTY(QString filename READ filename WRITE setFilename NOTIFY filenameChanged)
    Q_PROPERTY(QString passphrase READ filename WRITE setPassphrase NOTIFY passphraseChanged)

public:
    KeyGenerator();
    ~KeyGenerator();

    QString type();
    void setType(const QString &t);

    QStringList types();

    QString filename();
    void setFilename(const QString &f);

    QString passphrase();
    void setPassphrase(const QString &p);

public slots:
    void generateKey();

signals:
    void typeChanged();
    void typesChanged();
    void filenameChanged();
    void passphraseChanged();
    void keyGenerated(bool success);

private:
    QString _type;
    QString _filename;
    QString _passphrase;
    QStringList _types;
};
#endif

Next, we need to derive our class from QObject. We declare any properties that we want and the associated methods. Notify methods become signals. In our case, we want to have properties for the selected key type, the list of all valid ssh key types, file name and pass phrase. I arbitrarily made the key type a string. It could have been an enumerated type but it would have made the example more complicated.

Incidentally, a new feature of the Q_PROPERTY macro in Qt 5.1.0 is the MEMBER argument. It allows specifying a class member variable that will be bound to a property without the need to implement the setter or getter functions. That feature was not used here.

We declare methods for the setters and getters and for signals. We also declare one slot called generateKey(). These will all be available to QML. If we wanted to export a regular method to QML, we could mark it with Q_INVOCABLE. In this case I decided to make generateKey() a slot since it might be useful in the future but it could have just as easily been an invocable method.

Finally, we declare any private member variables we will need.

C++ Implementation

Now let’s look at the implementation in KeyGenerator.cpp. Here is the source code:

#include <QFile>
#include <QProcess>
#include "KeyGenerator.h"

KeyGenerator::KeyGenerator()
    : _type("rsa"), _types{"dsa", "ecdsa", "rsa", "rsa1"}
{
}

KeyGenerator::~KeyGenerator()
{
}

QString KeyGenerator::type()
{
    return _type;
}

void KeyGenerator::setType(const QString &t)
{
    // Check for valid type.
    if (!_types.contains(t))
        return;

    if (t != _type) {
        _type = t;
        emit typeChanged();
    }
}

QStringList KeyGenerator::types()
{
    return _types;
}

QString KeyGenerator::filename()
{
    return _filename;
}

void KeyGenerator::setFilename(const QString &f)
{
    if (f != _filename) {
        _filename = f;
        emit filenameChanged();
    }
}

QString KeyGenerator::passphrase()
{
    return _passphrase;
}

void KeyGenerator::setPassphrase(const QString &p)
{
    if (p != _passphrase) {
        _passphrase = p;
        emit passphraseChanged();
    }
}

void KeyGenerator::generateKey()
{
    // Sanity check on arguments
    if (_type.isEmpty() or _filename.isEmpty() or
        (_passphrase.length() > 0 and _passphrase.length() < 5)) {
        emit keyGenerated(false);
        return;
    }

    // Remove key file if it already exists
    if (QFile::exists(_filename)) {
        QFile::remove(_filename);
    }

    // Execute ssh-keygen -t type -N passphrase -f keyfileq
    QProcess *proc = new QProcess;
    QString prog = "ssh-keygen";
    QStringList args{"-t", _type, "-N", _passphrase, "-f", _filename};
    proc->start(prog, args);
    proc->waitForFinished();
    emit keyGenerated(proc->exitCode() == 0);
    delete proc;
}

The constructor initializes some of the member variables. For fun, I used the new initializer list feature of C++11 to initialize the _types member variable which is of type QStringList. The destructor does nothing, at least for now, but is there for completeness and future expansion.

Getter functions like type() simply return the appropriate private member variable. Setters set the appropriate variables, taking care to check that the new value is different from the old one and if so, emitting the appropriate signal. As always, please note that signals are created by the Meta Object Compiler and do not need to be implemented, only emitted at the appropriate times.

The only non-trivial method is the slot generateKey(). It does some checking of arguments and then creates a QProcess to run the external ssh-keygen program. For simplicity and because it typically executes quickly, I do this synchronously and block on it to complete. When done, we emit a signal that has a boolean argument that indicates the key was generated and whether it succeeded or not.

QML Code

Now let’s look at the QML code in main.qml:

// SSH key generator UI

import QtQuick 2.1
import QtQuick.Controls 1.0
import QtQuick.Layouts 1.0
import QtQuick.Dialogs 1.0
import com.ics.demo 1.0

ApplicationWindow {
    title: qsTr("SSH Key Generator")

    statusBar: StatusBar {
    RowLayout {
        Label {
            id: status
            }
        }
    }

    width: 369
    height: 166

    ColumnLayout {
        x: 10
        y: 10

        // Key type
        RowLayout {
            Label {
                text: qsTr("Key type:")
            }
            ComboBox {
                id: combobox
                Layout.fillWidth: true
                model: keygen.types
                currentIndex: 2
            }
        }

        // Filename
        RowLayout {
            Label {
                text: qsTr("Filename:")
            }
            TextField {
                id: filename
                implicitWidth: 200
                onTextChanged: updateStatusBar()
            }
            Button {
                text: qsTr("&Browse...")
                onClicked: filedialog.visible = true
            }
        }

        // Passphrase
        RowLayout {
            Label {
                text: qsTr("Pass phrase:")
            }
            TextField {
                id: passphrase
                Layout.fillWidth: true
                echoMode: TextInput.Password
                onTextChanged: updateStatusBar()
            }

        }

        // Confirm Passphrase
        RowLayout {
            Label {
                text: qsTr("Confirm pass phrase:")
            }
            TextField {
                id: confirm
                Layout.fillWidth: true
                echoMode: TextInput.Password
                onTextChanged: updateStatusBar()
            }
        }

        // Buttons: Generate, Quit
        RowLayout {
            Button {
                id: generate
                text: qsTr("&Generate")
                onClicked: keygen.generateKey()
            }
            Button {
                text: qsTr("&Quit")
                onClicked: Qt.quit()
            }
        }

    }

    FileDialog {
        id: filedialog
        title: qsTr("Select a file")
        selectMultiple: false
        selectFolder: false
        nameFilters: 
        selectedNameFilter: "All files (*)"
        onAccepted: {
            filename.text = fileUrl.toString().replace("file://", "")
        }
    }

    KeyGenerator {
        id: keygen
        filename: filename.text
        passphrase: passphrase.text
        type: combobox.currentText
        onKeyGenerated: {
            if (success) {
                status.text = qsTr('<font color="green">Key generation succeeded.</font>')
            } else {
                status.text = qsTr('<font color="red">Key generation failed</font>')
            }
        }
    }

    function updateStatusBar() {
        if (passphrase.text != confirm.text) {
            status.text = qsTr('<font color="red">Pass phrase does not match.</font>')
            generate.enabled = false
        } else if (passphrase.text.length > 0 && passphrase.text.length < 5) {
            status.text = qsTr('<font color="red">Pass phrase too short.</font>')
            generate.enabled = false
        } else if (filename.text == "") {
            status.text = qsTr('<font color="red">Enter a filename.</font>')
            generate.enabled = false
        } else {
            status.text = ""
            generate.enabled = true
        }
    }

    Component.onCompleted: updateStatusBar()
}

The preceding code is a little long, however, much of the work is laying out the GUI components. The code should be straightforward to follow.

Note that we import com.ics.demo version 1.0. We’ll see where this module name comes from shortly. This makes a new QML type KeyGeneratoravailable and so we declare one. We have access to it’s C++ properties as QML properties, can call it’s methods and act on signals like we do withonKeyGenerated.

A more complete program should probably do a little more error checking and report meaningful error messages if key generation fails (we could easily add a new method or property for this). The UI layout could also be improved to make it properly resizable.

Our main program is essentially a wrapper like qmlscene. All we need to do to register our type with the QML engine is to call:

    qmlRegisterType<KeyGenerator>("com.ics.demo", 1, 0, "KeyGenerator");

This makes the C++ type KeyGenerator available as the QML type KeyGenerator in the module com.ics.demo version 1.0 when it is imported.

Typically, to run QML code from an executable, in the main program you would create a QGuiApplication and a QQuickView. Currently, to use the Qt Quick Components there is some additional work needed if the top level element is an ApplicationWindow or Window. You can look at the source code to see how I implemented this. I basically stripped down the code from qmlscene to the minimum of what was needed for this example.

Here is the full listing for the main program, main.cpp:

#include <QApplication>
#include <QObject>
#include <QQmlComponent>
#include <QQmlEngine>
#include <QQuickWindow>
#include <QSurfaceFormat>
#include "KeyGenerator.h"

// Main wrapper program.
// Special handling is needed when using Qt Quick Controls for the top window.
// The code here is based on what qmlscene does.

int main(int argc, char ** argv)
{
    QApplication app(argc, argv);

    // Register our component type with QML.
    qmlRegisterType<KeyGenerator>("com.ics.demo", 1, 0, "KeyGenerator");

    int rc = 0;

    QQmlEngine engine;
    QQmlComponent *component = new QQmlComponent(&engine);

    QObject::connect(&engine, SIGNAL(quit()), QCoreApplication::instance(), SLOT(quit()));

    component->loadUrl(QUrl("main.qml"));

    if (!component->isReady() ) {
        qWarning("%s", qPrintable(component->errorString()));
        return -1;
    }

    QObject *topLevel = component->create();
    QQuickWindow *window = qobject_cast<QQuickWindow *>(topLevel);

    QSurfaceFormat surfaceFormat = window->requestedFormat();
    window->setFormat(surfaceFormat);
    window->show();

    rc = app.exec();

    delete component;
    return rc;
}

In case it is not obvious, when using a module written in C++ with QML you cannot use the qmlscene program to execute your QML code because the C++ code for the module will not be linked in. If you try to do this you will get an error message that the module is not installed.