Building your own Amazon Ring Security System

With a simple webcam, your program will be able to recognize the faces of people you choose to allow into the system. It will trigger a text, email, and snapshot image alert system, if any unrecognized faces appear in front of your webcam. We’ll also use Cloudinary and PubNub to build a React Native application that can receive a snapshot image of an “intruder’s” face. It will also allow a user to be added to the system if you desire.

What is Computer Vision?

Computer Vision is a specific field in artificial intelligence that deals with training machine learning models to understand and interpret the visual world. By learning from images and frames from cameras and videos, a computer vision AI can accurately classify the objects it sees and subsequently perform reactionary tasks just like we humans do.

Source Accessed 7/31/19

Python Code for Your FaceTracking Alert System

Before jumping into the code, be sure you sign up for a free PubNub account so we don’t run into any issues later.

To start building the project from scratch, create your project’s directory using your computer’s command line app:

mkdir faceTrackingApp
cd faceTrackingApp

Then create a new Python file called facetracker.py.

Libraries and Dependencies for Computer Vision

OpenCV and face_recognition

First, let's import some machine learning libraries for our app's face tracking capabilities. The main libraries we are going to use are OpenCV and face_recognition.

import face_recognition # Machine Learning Library for Face Recognition
import cv2 # OpenCV
import numpy as np # Handling data
import time
import os,sys

OpenCV is the most popular machine learning library for realtime Computer Vision. The library has useful tools such as webcam control as well as models to train a face tracking app from scratch. However, our project will primarily use ageitgey's face_recognition python library as it already comes with a face recognition model out of the box, making it extremely quick and easy to use.

PubNub

Next, we're going to setup PubNub as our Data Stream Network to handle all of the data between our Python script and mobile application. After you've retrieved your free PubNub API keys, install the PubNub Python SDK.

pip install 'pubnub>=4.1.4'

Then, import the library in your python file,

from pubnub.callbacks import SubscribeCallback
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
from pubnub.enums import PNOperationType, PNStatusCategory

and configure a PubNub instance with your API keys.

# PubNub Config
pnconfig = PNConfiguration()
pnconfig.subscribe_key = "YOUR_SUBSCRIBE_KEY"
pnconfig.publish_key = "YOUR_PUBLISH_KEY"
pnconfig.ssl = False
pubnub = PubNub(pnconfig)

Cloudinary

Lastly, we will setup Cloudinary as our Content Delivery Network to store images of intruders' faces. This will work beautifully with PubNub as our python script can upload the image to Cloudinary, get the URL from the response, then PubNub will send that URL to our Client app to render. First, sign up for a free Cloudinary account and then install the Cloudinary Python SDK with:

pip install cloudinary

Setup the CLOUDINARY_URL environment variable by copying it from the Management Console. Using zsh/bash/sh:

export CLOUDINARY_URL=cloudinary://API-Key:API-Secret@Cloud-name

Import the library in your Python script,

from cloudinary.api import delete_resources_by_tag, resources_by_tag
from cloudinary.uploader import upload
from cloudinary.utils import cloudinary_url

and configure a Cloudinary instance.

# Cloudinary Config
os.chdir(os.path.join(os.path.dirname(sys.argv[0]), '.'))
if os.path.exists('settings.py'):
    exec(open('settings.py').read())
DEFAULT_TAG = "python_sample_basic"

Machine Learning Face Tracking Algorithm

Before we begin building our face recognition machine learning model, we'll need to declare some global variables:

# Setup some Global Variables
video_capture = cv2.VideoCapture(0) # Webcam instance
known_face_names = [] # Names of faces
known_face_encodings = [] # Encodings of Faces
count = 0 # Counter for Number of Unknown Users
flag = 0 # Flag for Setting/Unsetting "Intruder Mode"
[NOTE: We create a count variable for the unknown users because we are going to dynamically save the user's snapshot image in a file path.] We're going to append the count to the file name like an ID tag. In order to find this snapshot image later, we need to pull up that user's count variable, so we can find the image in the file path. To start training our face recognizer model, we’ll begin with two sample images of faces. You will need two images of two different people's faces in your project directory.# Load a sample picture and learn how to recognize it.
sample_face_1 = face_recognition.load_image_file("sample_1.jpeg")
sample_face_1_encoding = face_recognition.face_encodings(sample_face_1)[0]
Load a second sample picture and learn how to recognize it.
sample_face_2 = face_recognition.load_image_file(“17.png”)

sample_face_2_encoding = face_recognition.face_encodings(sample_face_2)[0]
Create arrays of known face encodings and their names
known_face_encodings = [

sample_face_1_encoding,

sample_face_2_encoding

]
Create Names for Sample Face encodings
known_face_names = [

“sample_1”,

“sample_2”

]
Initialize some variables
face_locations = []

face_encodings = []

face_names = []

process_this_frame = True

Next, we will declare a while loop that will run continuously for the duration of the app. The loop will be responsible for the main functions of our app:

• Turning on and displaying the webcam feed
• Tracking faces that appear in front of the webcam and drawing a red box around the face in realtime
• Displaying a name below a known user’s face and “Unknown” for a face that has not been added to the database
• Calling a series of Alerts and Functions to handle when an “Unknown” face appears on screen

while(True):

video_capture = cv2.VideoCapture(0)
# Grab a single frame of video
ret, frame = video_capture.read()

# Resize frame of video to 1/4 size for faster face recognition processing
small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)

# Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses)
rgb_small_frame = small_frame[:, :, ::-1]

# Only process every other frame of video to save time
if process_this_frame:
    # Find all the faces and face encodings in the current frame of video
    face_locations = face_recognition.face_locations(rgb_small_frame)
    face_encodings = face_recognition.face_encodings(rgb_small_frame, face_locations)

    face_names = []
    for face_encoding in face_encodings:
        # See if the face is a match for the known face(s)
        matches = face_recognition.compare_faces(known_face_encodings, face_encoding)
        name = "Unknown"

        # # If a match was found in known_face_encodings, just use the first one.
        # if True in matches:
        #     first_match_index = matches.index(True)
        #     name = known_face_names[first_match_index]

        # Or instead, use the known face with the smallest distance to the new face
        face_distances = face_recognition.face_distance(known_face_encodings, face_encoding)
        best_match_index = np.argmin(face_distances)
        if matches[best_match_index]:
            name = known_face_names[best_match_index]

        face_names.append(name)

        #---------------------See next section for this code block's explanation---------------------#

        ## Set Unknown User Flag and Send Alerts
        #global flag
        #if(name=='Unknown' and flag==0):
        #    flag = 1
        #    Alert()
        #
        #--------------------------------------------------------------------------------------------#

process_this_frame = not process_this_frame

# Display the results
for (top, right, bottom, left), name in zip(face_locations, face_names):
    # Scale back up face locations since the frame we detected in was scaled to 1/4 size
    top *= 4
    right *= 4
    bottom *= 4
    left *= 4

    # Draw a box around the face
    cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)

    # Draw a label with a name below the face
    cv2.rectangle(frame, (left, bottom - 35), (right, bottom), (0, 0, 255), cv2.FILLED)
    font = cv2.FONT_HERSHEY_DUPLEX
    cv2.putText(frame, name, (left + 6, bottom - 6), font, 1.0, (255, 255, 255), 1)

# Display the resulting image
cv2.imshow('Video', frame)

# Hit 'q' on the keyboard to quit!
if cv2.waitKey(10) & 0xFF == ord('q'):
    break

Release handle to the webcam
video_capture.release()

cv2.destroyAllWindows()

Sending Alerts

We shall take care of the case when an unregistered face appears in front of our webcam. We want our program to trigger an alert system the moment it sees an “Unknown” face. Luckily, all we need to do is add a few lines of code to our main while loop at the end of the for face_encoding in face_encodings:loop.

# Set Unknown User Flag and Send Alerts

global flag

if(name==‘Unknown’ and flag==0):

flag = 1 # Stop repeated calls of Alerts until after the Unknown User is dealt with

Alert() # Trigger Alert System

When the alert is triggered, we can then define a function to take a snapshot of the unknown user’s face, call a function to upload the snapshot to Cloudinary, and finally call our Text/Email alert function.

def Alert():

global count

video_capture = cv2.VideoCapture(0) # Create Open CV Webcam Instance

path = ‘./’ # Specify where you want the snapshot to be stored

name = ‘Unknown_User’ + str(count) # Append User ID to File Path

# Wait for 3 seconds
print('Taking picture in 3')
time.sleep(1)
print('Taking picture in 2')
time.sleep(1)
print('Taking picture in 1')
time.sleep(1)

# Take Picture
ret, frame = video_capture.read()

# Grayscale Image to save memory space
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

# Save Image in File Path
status = cv2.imwrite('% s/% s.jpg' % (path, name),gray)
print('Unknown User Saved to Database', status)

# Upload Snapshot to Cloudinary 
upload_files('% s/% s.jpg' % (path,name))

# Send Out Email and Text Alerts
sendAlerts()

[NOTE: We grayscale the image because the face recognizer doesn’t need color to determine facial features. We also store the snapshot image locally so we can add the face to the recognizer if the client wants to add the user later.] When defining our upload_files() function, we’re passing in the snapshot’s file path so Cloudinary knows where to upload the file from. We then get the response URL of where the image lives in the cloud. We send this url along with a user ID (count of Unknown user) over PubNub to our client application. The client application can then render the image of the snapshot from the Cloudinary URL.

def upload_files(msg):

global count # Make global changes to count

response = upload(msg, tags=DEFAULT_TAG) # Upload Image to Cloudinary

url, options = cloudinary_url(

response[‘public_id’],

format=response[‘format’],

width=200,

height=150,

crop=“fill”

)

dictionary = {“url”: url, “ID”: count}

pubnub.publish().channel(‘global’).message(dictionary).pn_async(publish_callback)

count+=1 # Increment Unknown User Count

In order to publish with PubNub, we need to define a publish callback.def publish_callback(result, status):

pass

# Handle PNPublishResult and PNStatus

 To setup your Text and Email alerts, you’ll need to sign up for a free ClickSend account as well as a free SendGrid account to get your API keys. Now you get to see the power and beauty behind PubNub Functions with our Partnered Blocks. Go ahead and visit both our ClickSend Block as well as our SendGrid Block. Through those links, PubNub will automatically generate a customizable PubNub Function. The serverless, open-source code will completely handle the APIs for you. All you need to do is put in your API keys and you’re good to go! Once you’ve set up your PubNub Functions, you can define a sendAlerts() function to publish a message, implementing your Text and Email alerts:def sendAlerts():

dictionary = {

“to” : ‘RECEIVING PHONE NUMBER’,

“body”: “There is an unregistered user at your desk!”

}

pubnub.publish().channel(‘clicksend-text’).message(dictionary).pn_async(publish_callback)

dictionary = {
"to": "EMAIL RECEIVER",
"toname": "EMAIL SENDER",
"subject": "INTRUDER ALERT",
"text": "THERE IS AN UNREGISTERED USER AT YOUR DESK"
}   
pubnub.publish().channel('email-sendgrid-channel').message(dictionary).pn_async(publish_callback)

NOTE: In order to properly use a PubNub block, you need to publish over the same channel specified in your block (you can check this in your blocks Functions dashboard) as well as formatting the message payload properly (according to the block’s documentation).

Adding Users to Our Facetracker

When an Unregistered face is detected on our webcam, our Python script sends an email/text alert as well as a snapshot image to our client application.We now want to add the ability to add a user’s face to our app’s “known_faces” database, so the user will no longer trigger our alert system. To do this, the client application must publish a message over PubNub. To receive this message in our python application, we must subscribe to the channel the client is publishing from, and create a Subscriber Callback to handle the incoming message.class MySubscribeCallback(SubscribeCallback):

def status(self, pubnub, status):

pass

# The status object returned is always related to subscribe but could contain

# information about subscribe, heartbeat, or errors

# use the operationType to switch on different options

if status.operation == PNOperationType.PNSubscribeOperation 

or status.operation == PNOperationType.PNUnsubscribeOperation:

if status.category == PNStatusCategory.PNConnectedCategory:

pass

# This is expected for a subscribe, this means there is no error or issue whatsoever

elif status.category == PNStatusCategory.PNReconnectedCategory:

pass

# This usually occurs if subscribe temporarily fails but reconnects. This means

# there was an error but there is no longer any issue

elif status.category == PNStatusCategory.PNDisconnectedCategory:

pass

# This is the expected category for an unsubscribe. This means here

# was no error in unsubscribing from everything

elif status.category == PNStatusCategory.PNUnexpectedDisconnectCategory:

pass

# This is usually an issue with the internet connection, this is an error, handle

# appropriately retry will be called automatically

elif status.category == PNStatusCategory.PNAccessDeniedCategory:

pass

# This means that PAM does not allow this client to subscribe to this

# channel and channel group configuration. This is another explicit error

else:

pass

# This is usually an issue with the internet connection, this is an error, handle appropriately

# retry will be called automatically

elif status.operation == PNOperationType.PNSubscribeOperation:

# Heartbeat operations can in fact have errors, so it is important to check first for an error.

# For more information on how to configure heartbeat notifications through the status

if status.is_error():

pass

# There was an error with the heartbeat operation, handle here

else:

pass

# Heartbeat operation was successful

else:

pass

# Encountered unknown status type

def presence(self, pubnub, presence):
    pass  # handle incoming presence data
def message(self, pubnub, message):
    addUser(message.message["ID"], message.message["name"])

pubnub.add_listener(MySubscribeCallback())

pubnub.subscribe().channels(‘ch1’).execute()

NOTE: Above we assume the client is publishing the ID of the unknown user (for image file path) as well as the name of the user (to display below the user’s face). With the parameters in hand, we can add the new user to our database.

def addUser(ID, name):

global known_face_encodings, known_face_names, flag

path = ‘./Unknown_User’ + str(ID) # Append User ID to File Path

# Load User’s picture and learn how to recognize it.

user_image = face_recognition.load_image_file(‘% s.jpg’ % (path)) # Load Image

user_face_encoding = face_recognition.face_encodings(user_image)[0] # Encode Image

known_face_encodings.append(user_face_encoding) # Add Encoded Image to ‘Known Faces’ Array

known_face_names.append(name) # Append New User’s Name to Database

flag = 0 # Reset Unknown User Flag

React Native Code for Our Client Application

Setting Up Our Realtime React Native Environment

Install Xcode so we can build and simulate our app for IOS and Android Studio for Android. Then install Node.js and watchman using Homebrew:

brew install node

brew install watchman

Install the React Native CLI with NPM:

npm install -g react-native-cli

To create a React Native App template, enter the React Native CLI command in your project’s directory:

react-native init client

cd client

Since we’re going to be using PubNub in our Client app to send and receive messages, we’ll need to install the PubNub React SDK,

npm install --save pubnub pubnub-react

and then link the library like so:

react-native link pubnub-react

Setting Up Realtime Pub/Sub Messaging

To start sending and receiving messages in realtime in our app, first import the PubNub React SDK.

import PubNubReact from ‘pubnub-react’;

Then import the TouchableOpacity and Image components from React Native,

import {

StyleSheet,

View,

Text,

TextInput,

TouchableOpacity,

Image,

} from ‘react-native’;

Now we add a constructor at the top of our App Component. The constructor will be responsible for setting up a PubNub instance with our Publish/Subscribe keys as well as initialize the following state variables:

• image - Snapshot image from an unknown user alert (we initialize it with a placeholder image until a Snapshot alert arrives).
• message - Incoming alert message from the face tracking app.
• text - Client user’s input for typing in the name of a user.
• count - To keep track of which unknown user we are getting an alert from.

export default class App extends React.Component {

constructor(props) {

super(props)
this.pubnub = new PubNubReact({
  publishKey: "YOUR PUBLISH KEY",
  subscribeKey: "YOUR SUBSCRIBE KEY"
})

//Base State
this.state = {
  image: require('./assets/PLACEHOLDER_IMAGE.jpg'),
  message: '',
  text: '',
  count: 0,
}

this.pubnub.init(this);

}
/// …VVV REST OF THE CODE VVV…///

When our client app first fires up, we declare an asynchronous function that will subscribe to our face tracking alert channel and handle message events. In this case, we receive the ID (count of unknown user) as well as the snapshot image URL (from Cloudinary) of the unknown user.async componentDidMount() {

this.setUpApp()

}
async setUpApp(){

this.pubnub.getMessage(“global”, msg => {

this.setState({count: msg.message.ID})

this.setState({image: msg.message.url})

})
this.pubnub.subscribe({

channels: [“global”],

withPresence: false

});

}

Once that image is received by the mobile app, the client user should then be able to add the unknown user to the face tracker’s “known_faces” database. We can define a function to set the state of the client user’s input for the unknown user’s name. handleText = (name) => {

this.setState({ text: name })

}

We can also write a function to publish the added user’s name along with the added user’s ID.

 publishName = (text) => {

this.pubnub.publish({

message: {

ID: this.state.count,

name: text,

},

channel: “ch1”

});

}

Creating and Rendering App Components

At the top of our screen we’ll render the snapshot image from an incoming “Unknown User” Alert. The source of this image will be a URI we grabbed from the alert message that we saved to state.

<Image   source={{uri: this.state.image}}   style={{width: 250, height: 250}}/>                 

Below that, we can display a suitable caption.

<Text>{‘Do You Know This Person?’}</Text>

We then create a Text Input component to store the name of the User to be added to the face tracker, if the client decides to do so.

<TextInput style = {styles.input}

underlineColorAndroid = “transparent”

placeholder = “Name”

placeholderTextColor = “#9a73ef”

autoCapitalize = “none”

onChangeText = {this.handleText}/>

Lastly, we create a submit button with TouchableOpacity to publish the added user’s name for our Face Tracker to add to the system:

<TouchableOpacity

style = {styles.submitButton}

onPress = {

() => this.publishName(this.state.text)

}>

<Text>“SUBMIT”</Text>

</TouchableOpacity>

Wrap all those components in a <View> </View> and you’re good to go!

Running the Program

First, start up the React Native client application on Android or iOS by opening a terminal in the client app’s directory.

react-native run-ios

or
react-native run-android

Then, in another terminal window, run the Python face tracker.

python facetracker.py

Conclusion

Thanks For Visiting, Keep Visiting.

#reactjs #react-native #machine-learning #security #web-development

What is GEEK

Buddha Community

Best Custom Web & Mobile App Development Company

Everything around us has become smart, like smart infrastructures, smart cities, autonomous vehicles, to name a few. The innovation of smart devices makes it possible to achieve these heights in science and technology. But, data is vulnerable, there is a risk of attack by cybercriminals. To get started, let’s know about IoT devices.

What are IoT devices?

The Internet Of Things(IoT) is a system that interrelates computer devices like sensors, software, and actuators, digital machines, etc. They are linked together with particular objects that work through the internet and transfer data over devices without humans interference.

Famous examples are Amazon Alexa, Apple SIRI, Interconnected baby monitors, video doorbells, and smart thermostats.

How could your IoT devices be vulnerable?

When technologies grow and evolve, risks are also on the high stakes. Ransomware attacks are on the continuous increase; securing data has become the top priority.

When you think your smart home won’t fudge a thing against cybercriminals, you should also know that they are vulnerable. When cybercriminals access our smart voice speakers like Amazon Alexa or Apple Siri, it becomes easy for them to steal your data.

Cybersecurity report 2020 says popular hacking forums expose 770 million email addresses and 21 million unique passwords, 620 million accounts have been compromised from 16 hacked websites.

The attacks are likely to increase every year. To help you secure your data of IoT devices, here are some best tips you can implement.

Tips to secure your IoT devices

1. Change Default Router Name

Your router has the default name of make and model. When we stick with the manufacturer name, attackers can quickly identify our make and model. So give the router name different from your addresses, without giving away personal information.

2. Know your connected network and connected devices

If your devices are connected to the internet, these connections are vulnerable to cyber attacks when your devices don’t have the proper security. Almost every web interface is equipped with multiple devices, so it’s hard to track the device. But, it’s crucial to stay aware of them.

3. Change default usernames and passwords

When we use the default usernames and passwords, it is attackable. Because the cybercriminals possibly know the default passwords come with IoT devices. So use strong passwords to access our IoT devices.

4. Manage strong, Unique passwords for your IoT devices and accounts

Use strong or unique passwords that are easily assumed, such as ‘123456’ or ‘password1234’ to protect your accounts. Give strong and complex passwords formed by combinations of alphabets, numeric, and not easily bypassed symbols.

Also, change passwords for multiple accounts and change them regularly to avoid attacks. We can also set several attempts to wrong passwords to set locking the account to safeguard from the hackers.

5. Do not use Public WI-FI Networks

Are you try to keep an eye on your IoT devices through your mobile devices in different locations. I recommend you not to use the public WI-FI network to access them. Because they are easily accessible through for everyone, you are still in a hurry to access, use VPN that gives them protection against cyber-attacks, giving them privacy and security features, for example, using Express VPN.

6. Establish firewalls to discover the vulnerabilities

There are software and firewalls like intrusion detection system/intrusion prevention system in the market. This will be useful to screen and analyze the wire traffic of a network. You can identify the security weakness by the firewall scanners within the network structure. Use these firewalls to get rid of unwanted security issues and vulnerabilities.

7. Reconfigure your device settings

Every smart device comes with the insecure default settings, and sometimes we are not able to change these default settings configurations. These conditions need to be assessed and need to reconfigure the default settings.

8. Authenticate the IoT applications

Nowadays, every smart app offers authentication to secure the accounts. There are many types of authentication methods like single-factor authentication, two-step authentication, and multi-factor authentication. Use any one of these to send a one time password (OTP) to verify the user who logs in the smart device to keep our accounts from falling into the wrong hands.

9. Update the device software up to date

Every smart device manufacturer releases updates to fix bugs in their software. These security patches help us to improve our protection of the device. Also, update the software on the smartphone, which we are used to monitoring the IoT devices to avoid vulnerabilities.

10. Track the smartphones and keep them safe

When we connect the smart home to the smartphone and control them via smartphone, you need to keep them safe. If you miss the phone almost, every personal information is at risk to the cybercriminals. But sometimes it happens by accident, makes sure that you can clear all the data remotely.

However, securing smart devices is essential in the world of data. There are still cybercriminals bypassing the securities. So make sure to do the safety measures to avoid our accounts falling out into the wrong hands. I hope these steps will help you all to secure your IoT devices.

If you have any, feel free to share them in the comments! I’d love to know them.

Are you looking for more? Subscribe to weekly newsletters that can help your stay updated IoT application developments.

#iot #enterprise iot security #how iot can be used to enhance security #how to improve iot security #how to protect iot devices from hackers #how to secure iot devices #iot security #iot security devices #iot security offerings #iot security technologies iot security plus #iot vulnerable devices #risk based iot security program

Lax Security Exposes Smart-Irrigation Systems to Attack Across the Globe

More than 100 smart-irrigation systems deployed across the globe were installed without changing the factory’s default, passwordless setting, leaving them vulnerable to malicious attacks, according to recent findings from Israeli security research firm Security Joes.

The researchers immediately alerted CERT Israel, the affected companies and the irrigation system vendor, Mottech Water Management, which did not immediately respond to a request for comment from Threatpost.

Mottech’s system allows for real-time control and monitoring of irrigation for both agricultural and turf/landscaping installations, via desktop and mobile phone. Sensor networks allow for the flexible and real-time allocation of water and fertilizer to different valves in the system. Access to the network could result in an attacker being able to flood fields or over-deliver fertilizer, for instance.

Security Joes regularly scans for Israeli open devices on the internet to check for vulnerabilities, the firm’s co-founder Ido Naor told Threatpost. Recently, its researchers discovered that 55 irrigation systems within Israel were visible on the open internet without password protections. After expanding their search, they found 50 others scattered around the world in countries including France, South Korea, Switzerland and the U.S.

“We’re talking about full-fledged irrigation systems, they could be entire cities,” Naor said. “We don’t look closely at what’s behind the address, because we don’t want to cause any trouble.”

Naor said that at last check, only about 20 percent of the identified vulnerable irrigation devices have had mitigation efforts taken to protect them so far.

Israel’s Water Systems Under Attack

There’s good reason for alarm about water systems not being secured, particularly in Israel. Just last April, a cyberattack on Israeli water systems, reportedly launched by Iran, attempted to increase the mix of chlorine in the water to poison the civilian population and ultimately interrupt the population’s water supply, The Times of Israel reported.

Yigal Unna, the head of the country’s National Cyber Directorate addressed the CybertechLive Asia conference in late May with the ominous warning that the direct cyberattack on people represented a new chapter in cyberwarfare, according to The Times of Israel.

“Cyber-winter is coming and coming even faster than I suspected,” he told the conference, according to the report. “We are just seeing the beginning.”

Unna was correct. Just weeks later in July, the Israeli Water Authority said that it was able to stop an attack on agricultural water pumps in Galilee, and another on water-supply infrastructure in the “center of the country,” reports.

The irrigation systems which were discovered without password protection aren’t related to the previous attacks, Naor said.

Locking Down Utilities Beyond Israel

These types of vulnerabilities certainly aren’t limited to Israel.

Last month, six critical flaws in CodeMeter, software used to power industrial systems in the U.S., including water and electric utilities, were discovered which could be exploited to launch attacks or even allow third-party takeovers of systems.

Over the summer, researchers found that VPNs used for remote access to operational technology (OT) networks in industrial environments left field devices open to attacks, which could cause shutdowns or even physical damage.

Governments are making attempts to keep up with the proliferation of internet-of-things (IoT) devices throughout critical-infrastructure systems. In the U.S., the House of Representatives passed legislation in September establishing minimum requirements for IoT devices within the federal government.

“Most experts expect tens of billions of devices operating on our networks within the next several years as the [IoT] landscape continues to expand,” the legislation’s so-sponsor Senator Cory Gardner (R-Co.) said in a press release. “We need to make sure these devices are secure from malicious cyberattacks as they continue to transform our society and add countless new entry points into our networks, particularly when they are integrated into the federal government’s networks.”

#cloud security #critical infrastructure #iot #web security #connected devices #cory gardner bill #critical infrastructure #cyberattack #cybersecurity #default password #galilee #government #infrastructure security #internet of things #irrigation systems #israel #mottech water management #open to internet #security joes #smart irrigation #water system attacks

System Databases in SQL Server

Introduction

In SSMS, we many of may noticed System Databases under the Database Folder. But how many of us knows its purpose?. In this article lets discuss about the System Databases in SQL Server.

System Database

Fig. 1 System Databases

There are five system databases, these databases are created while installing SQL Server.

• Master
• Model
• MSDB
• Tempdb
• Resource

Master

• This database contains all the System level Information in SQL Server. The Information in form of Meta data.
• Because of this master database, we are able to access the SQL Server (On premise SQL Server)

Model

• This database is used as a template for new databases.
• Whenever a new database is created, initially a copy of model database is what created as new database.

MSDB

• This database is where a service called SQL Server Agent stores its data.
• SQL server Agent is in charge of automation, which includes entities such as jobs, schedules, and alerts.

TempDB

• The Tempdb is where SQL Server stores temporary data such as work tables, sort space, row versioning information and etc.
• User can create their own version of temporary tables and those are stored in Tempdb.
• But this database is destroyed and recreated every time when we restart the instance of SQL Server.

Resource

• The resource database is a hidden, read only database that holds the definitions of all system objects.
• When we query system object in a database, they appear to reside in the sys schema of the local database, but in actually their definitions reside in the resource db.

#sql server #master system database #model system database #msdb system database #sql server system databases #ssms #system database #system databases in sql server #tempdb system database

Empower your e-commerce business by building an app like Amazon

We at Appdupe incorporate the app with the latest techniques to meet the customer market trend. The app is enriched with the highly-advanced and innovative features that help you deliver the best Amazon clone script that helps turn your e-commerce business ideas into reality. We offer a top-notch Amazon clone app development and a ready-made clone application perfect for any business sector. Every feature in it is set to expand your business, which can also be altered with your brand name. By developing an app like Amazon, you can easily reach your customer anytime anywhere that eventually helps increase the business revenue.

Read More, https://www.appdupe.com/amazon-clone

#amazon clone #amazon clone app #amazon clone app development #amazon clone script #amazon app clone #amazon like app development

50+ Useful Kubernetes Tools for 2020 - Part 2

Introduction

Last year, we provided a list of Kubernetes tools that proved so popular we have decided to curate another list of some useful additions for working with the platform—among which are many tools that we personally use here at Caylent. Check out the original tools list here in case you missed it.

According to a recent survey done by Stackrox, the dominance Kubernetes enjoys in the market continues to be reinforced, with 86% of respondents using it for container orchestration.

(State of Kubernetes and Container Security, 2020)

And as you can see below, more and more companies are jumping into containerization for their apps. If you’re among them, here are some tools to aid you going forward as Kubernetes continues its rapid growth.

(State of Kubernetes and Container Security, 2020)

#blog #tools #amazon elastic kubernetes service #application security #aws kms #botkube #caylent #cli #container monitoring #container orchestration tools #container security #containers #continuous delivery #continuous deployment #continuous integration #contour #developers #development #developments #draft #eksctl #firewall #gcp #github #harbor #helm #helm charts #helm-2to3 #helm-aws-secret-plugin #helm-docs #helm-operator-get-started #helm-secrets #iam #json #k-rail #k3s #k3sup #k8s #keel.sh #keycloak #kiali #kiam #klum #knative #krew #ksniff #kube #kube-prod-runtime #kube-ps1 #kube-scan #kube-state-metrics #kube2iam #kubeapps #kubebuilder #kubeconfig #kubectl #kubectl-aws-secrets #kubefwd #kubernetes #kubernetes command line tool #kubernetes configuration #kubernetes deployment #kubernetes in development #kubernetes in production #kubernetes ingress #kubernetes interfaces #kubernetes monitoring #kubernetes networking #kubernetes observability #kubernetes plugins #kubernetes secrets #kubernetes security #kubernetes security best practices #kubernetes security vendors #kubernetes service discovery #kubernetic #kubesec #kubeterminal #kubeval #kudo #kuma #microsoft azure key vault #mozilla sops #octant #octarine #open source #palo alto kubernetes security #permission-manager #pgp #rafay #rakess #rancher #rook #secrets operations #serverless function #service mesh #shell-operator #snyk #snyk container #sonobuoy #strongdm #tcpdump #tenkai #testing #tigera #tilt #vert.x #wireshark #yaml