Auto news on Youtube Dec 2 2017

Hi this is Phil from Make Tech Easier and welcome to how to install Linux software

on a Mac with MacPorts. MacPorts is a command-line package manager for macOS.

If you're familiar with apt-get or yum in Linux then you know what a package

manager does. It handles downloading, installing, updating and managing certain

applications and their dependencies within Mac OS. With MacPorts you can

install Linux applications on macOS from the command line.

What can I install? Most of these applications are open source command

line utilities but there are a fair share of real open source GUI based

applications as well. Like any package manager MacPorts searches the library of

downloadable software. When you find what you need to make ports downloads and

installs the appropriate software and dependencies in the right place. This

saves you the trouble of downloading repositories from GitHub and building

software from source packages while still getting access to a wide range of

Linux's best command-line tools and GUI applications. If you read our post on

Homebrew (link in the description) you know that macOS is missing some standard Linux terminal commands

out-of-the-box. Mac users won't find common command-line tools like nmap or

wget and there's no native package manager on the Mac to provide

them. You can also use Mac ports to install open source software like GIMP.

Installing MacPorts. MacPorts requires the latest version of

XCode for your OS version. You can download XCode from the Mac App Store or

Apple's developer website. (Links in the description.) Well you can run most of the

MacPort commands without XCode you won't be able to run many of the

packages until you install it. Installing XCode developer tools. First

open terminal and use the command below to trigger the installation of macOS

developers tools. Secondly click install in the pop-up box. Wait for the files to

download and install. Installing the MacPorts package. If you already have the

XCode and the developer tools installed you can jump right to this step. Firstly

download the latest release of MacPorts from GitHub.

Make sure you scroll down to choose the version that matches your version of macOS.

Install the package from your downloads folder. Open a new terminal

window and run the command "port". If that command returns MacPorts 2.4.1

and provides a slightly different looking command prompt then

you're ready to rock. Install Linux apps with MacPorts. To install some Linux app

on macOS with MacPorts we will first need to search for the relevant programs.

To see a gigantic list of all available packages open terminal and type "port

list" and press Enter.

Obviously that's a lot to look through. We can use the "port search" command to

find something specific. Let's search for nmap using the command "port search nmap".

That returns a few matching packages. The first one just called nmap is the

one we're looking for. To get more information about that package we can

use the info command. That returns some specific information about nmap. That all

looks good so we can install with the command "sudo port install nmap". Note

to the "sudo-" prefix which will require your admin password to fire. Depending on

the package you're installing there might be a large list of dependencies. These

are software packages that your desired port relies on and you'll need to

install them along with your port of choice. Type Y and press ENTER to accept

the installation. When the installation is complete you can run the command as

you would on Linux via terminal. Conclusion. MacPorts is a powerful

package manager that will connect you to a huge array of open source binaries and

applications that you can download and install on demand. If you want to learn

more of the applications commands you can check out the MacPorts guide for

more information. (Link in the description.) OK as always thanks for watching and

please subscribe and add your comments below. See you next time!

For more infomation >> How to Install Linux Software on a Mac with MacPorts - Duration: 4:47.

-------------------------------------------

VulCAN: Efficient Component Authentication and Software Isolation for Automotive Control Networks - Duration: 4:42.

Modern cars are operated via an internal network of more than 50 Electronic

Control Units.

Recent incidents have shown such ECUs to be vulnerable to

various kinds of remote attacks, which threatens the safety of passengers

and other road users alike.

While recent standardization and research efforts address security, few security mechanisms

are implemented in current cars.

In this video we demonstrate VulCAN, a lightweight and efficient framework

for implementing industry standard-compliant and secure vehicular

communication, based on embedded trusted computing.

We use the open-source Sancus hardware-level security architecture

to establish trust in a simplified traction control system.

Our demo system consists of a number of ECUs some of which represent

sensors or actuators at the wheels, other ECUs perform centralized

processing tasks.

All ECUs are interconnected via a Controller Area

Network, the blue cable in our demo setup.

CAN is the most prevalent network in vehicles, and enables ECUs to jointly

operate the car's overall behavior and safety critical functionality.

To demonstrate real-world applicability, we connected two off-the-shelf

instrument clusters.

An important feature of VulCAN is software extensibility by multiple,

distrusting remote software providers.

We therefore organized our demo application as a distributed set of trusted

software components, which are compiled on a PC and subsequently deployed

over an untrusted network to the ECUs.

Untrusted support software on the participating ECUs loads and

schedules the trusted components, whereas their authenticity can be

established at runtime through a process known as remote attestation.

The black keypad abstracts genuine driver interaction via steering wheel

and brake pedals.

Inputs from this keypad are processed on a central ECU,

which reacts by sending control messages over the CAN bus.

CAN is a broadcast medium.

Anyone connected to the bus can see or even modify these messages.

We show this by recording all traffic on the PC.

ECUs at the wheels or within the instrument clusters react upon receiving

control messages.

Many attacks against automotive control networks rely on an attacker with

access to the CAN bus to inject arbitrary messages.

In our demo we even go one step further and assume a powerful attacker

that also executes software on the crucial central ECU.

These attacker interactions are triggered by

the red keypad.

Under attack, the left and the right side of the setup behave differently.

The right side shows how a car without our security solution would react.

As the attacker sends messages to activate the direction indicators and to

display a high engine speed, the right instrument cluster and ECUs accept

and display the spoofed values.

Our vulcanized components on the left side accept authenticated messages

only, and indeed reject the attacker's messages.

We demonstrate how unmodified legacy devices without Sancus can

be transparently shielded.

For this, we connect a second instrument cluster

to a VulCAN gateway, which forwards authenticated messages from the untrusted

blue CAN bus over the yellow private CAN bus.

The gateway ensures that attacker messages are

rejected.

The driver can even be notified of an ongoing attack by

triggering a warning indicator in the dashboard.

Our demo illustrates that vulcanized software components never react to

injected messages for which authenticity and freshness cannot be verified.

Even a powerful attacker with code execution abilities on ECUs will not be

able to extract the required cryptographic keys to construct such

authenticated messages due to the strong isolation guarantees provided by

the underlying Sancus architecture.

Yet, such an attacker may harm availability by monopolizing an ECU or by

performing denial-of-service attacks against the network, which are domains

of active ongoing research at DistriNet.

Since we value both research transparency and reproducibility, we

open-sourced all of our hardware designs, plus the complete software stack,

and a simulator.

For more info, and related research efforts, visit the

VulCAN and Sancus websites/GitHub pages linked below.