Today, Microsoft and partners across 35 countries took coordinated legal and technical steps to disrupt one of the world’s most prolific botnets, called Necurs, which has infected more than nine million computers globally. This disruption is the result of eight years of tracking and planning and will help ensure the criminals behind this network are no longer able to use key elements of its infrastructure to execute cyberattacks.

A botnet is a network of computers that a cybercriminal has infected with malicious software, or malware. Once infected, criminals can control those computers remotely and use them to commit crimes. Microsoft’s Digital Crimes Unit, BitSight and others in the security community first observed the Necurs botnet in 2012 and have seen it distribute several forms of malware, including the GameOver Zeus banking trojan.

The Necurs botnet is one of the largest networks in the spam email threat ecosystem, with victims in nearly every country in the world. During a 58-day period in our investigation, for example, we observed that one Necurs-infected computer sent a total of 3.8 million spam emails to over 40.6 million potential victims.

Necurs is believed to be operated by criminals based in Russia and has also been used for a wide range of crimes including pump-and-dump stock scams, fake pharmaceutical spam email and “Russian dating” scams. It has also been used to attack other computers on the internet, steal credentials for online accounts, and steal people’s personal information and confidential data. Interestingly, it seems the criminals behind Necurs sell or rent access to the infected computer devices to other cybercriminals as part of a botnet-for-hire service. Necurs is also known for distributing financially targeted malware and ransomware, cryptomining, and even has a DDoS (distributed denial of service) capability that has not yet been activated but could be at any moment.

On Thursday, March 5, the U.S. District Court for the Eastern District of New York issued an order enabling Microsoft to take control of U.S.-based infrastructure Necurs uses to distribute malware and infect victim computers. With this legal action and through a collaborative effort involving public-private partnerships around the globe, Microsoft is leading activities that will prevent the criminals behind Necurs from registering new domains to execute attacks in the future.

This was accomplished by analyzing a technique used by Necurs to systematically generate new domains through an algorithm. We were then able to accurately predict over six million unique domains that would be created in the next 25 months. Microsoft reported these domains to their respective registries in countries around the world so the websites can be blocked and thus prevented from becoming part of the Necurs infrastructure. By taking control of existing websites and inhibiting the ability to register new ones, we have significantly disrupted the botnet.

Microsoft is also taking the additional step of partnering with Internet Service Providers (ISPs) and others around the world to rid their customers’ computers of malware associated with the Necurs botnet. This remediation effort is global in scale and involves collaboration with partners in industry, government and law enforcement via the Microsoft Cyber Threat Intelligence Program (CTIP). Through CTIP, Microsoft provides law enforcement, government Computer Emergency Response Teams (CERTs), ISPs and government agencies responsible for the enforcement of cyber laws and the protection of critical infrastructure with better insights into criminal cyber infrastructure located within their jurisdiction, as well as a view of compromised computers and victims impacted by such criminal infrastructure.

For this disruption, we are working with ISPs, domain registries, government CERTs and law enforcement in Mexico, Colombia, Taiwan, India, Japan, France, Spain, Poland and Romania, among others. Each of us has a critical role to play in protecting customers and keeping the internet safe.

To make sure your computer is free of malware, visit support.microsoft.com/botnets.

Tags: botnet, CTIP, cyberattacks, cybercrime, Microsoft Cyber Threat Intelligence Program, necurs

While streaming and uploading footage of video games online has become a common practice nowadays, not every company is necessarily thrilled about it. For example, a number of Japanese companies like Arc System Works and Atlus have released special recording and streaming guidelines for their new releases.

In 2017, Nintendo even went to the extent of ruling out live streaming of its games on YouTube. Fortunately, it ended up replacing this program with new guidelines early last year. As the company slowly begins to warm up to the idea of its game footage being shared online by creators, the famous Nintendo game designer Shigeru Miyamoto has recently shared his own thoughts about players uploading gameplay videos.

The response comes from his recent 12-page Famitsu interview, and was translated by BlackKite (via Japanese Nintendo):

I think it’s good that there’s a variety of ways to enjoy things. In the ROM era, we preferred to have [customers] play for a long time with materials created with very miniscule memory without publicising them. At that time, it would be problematic if the whole game content were to be revealed. But it is now an era where customers that bought [the games] publish videos broadly, and I think that may pique interest about those games to other people who watch it. I think I would also watch walkthrough videos of [games] made by someone else. Honestly, I don’t want to watch my own [games], but if it’s made by someone else it should still be okay.

As Miyamoto explains, sharing gameplay footage online can obviously help pique interest in certain titles. It’s also a great way to see a walkthrough of a video game. When Nintendo relaxed its content creator guidelines last year, the global head of YouTube said the video platform was glad to see the company take a “big step forward” and that it was a testament to what the power of creators can do.

What do you think about Miyamoto’s response? Does Nintendo need to do more? Share your thoughts below.

Earlier this year Respawn debuted new playable Apex Legends character Revenant with a bit of a bait-and-switch, introducing him as the assassin of Forge, a ringer which design director Jason McCord told Dot eSports was designed explicitly to foil data miners and leakers.

“It started as a fun way to misdirect data miners who, at the time, felt like they had solved our next legend and had ruined our surprise,” said McCord, who credited the idea to Apex Legends designer Rayme Vinson. “We actually purposefully leaked fake concept art and details of Forge’s kit in patches, so there would be a bread crumb trail by the time we announced him. It’s pretty insane, really. I can’t think of any other game that has gone through such hijinks.”

It’s a remarkable bit of effort to outwit data miners and, sure enough, it seems many Apex Legends players were earnestly surprised by Revenant’s reveal, presaged by an animated teaser in which Forge is murdered mid-interview by the rapacious robot.

The surprise appeared to land even though Revenant’s existence was leaked ahead of time by said data miners, whose efforts continue to frustrate McCord and other game developers. Late last year, for example, Blizzard’s Jeff Kaplan made a point of highlighting how leaks of a game’s existence or assets can negatively impact game devs’ morale, as they lose out on getting to promote something they’ve worked hard on and instead often have to deal with misunderstandings and mistaken assumptions based on incomplete or unfinished work.

This week many at Microsoft began working from home for an extended period due to COVID-19 concerns, and now the company says even though hourly contractors are working less, it still plans to pay them their usual rates.

“We recognize the hardship that lost work can mean for hourly employees,” reads today’s company blog post.  “As a result, we’ve decided that Microsoft will continue to pay all our vendor hourly service providers their regular pay during this period of reduced service needs. This is independent of whether their full services are needed.”

As COVID-19 drives more game makers to embrace the convenience of remote computing and collaboration, this is a good reminder that a lot of people whose labor is critical to the industry don’t have the same luxury. Microsoft makes a point of recognizing the contributions of on-site hourly workers, including folks who drive shuttles, care for on-site food services, and support Microsoft’s IT and A/V needs.

“We’re committed as a company to making public health our first priority and doing what we can to address the economic and societal impact of COVID-19​,” the Microsoft post continues. “We appreciate that what’s affordable for a large employer may not be affordable for a small business, but we believe that large employers who can afford to take this type of step should consider doing so.”

Destiny 2 developer Bungie announced this week it would enact a remote work policy in order to help curb the spread of COVID-19, while Take-Two CEO Strauss Zelnick suggested that the outbreak could lead to a seachange in how the game industry views remote work at large.

So you have two or more lists and you want to glue them together. This is called list concatenation. How can you do that?

These are six ways of concatenating lists:

1. List concatenation operator +
2. List append() method
3. List extend() method
4. Asterisk operator *
5. Itertools.chain()
6. List comprehension

a = [1, 2, 3]

b = [4, 5, 6] # 1. List concatenation operator +

l_1 = a + b # 2. List append() method

l_2 = [] for el in a: l_2.append(el) for el in b: l_2.append(el) # 3. List extend() method

l_3 = []

l_3.extend(a)

l_3.extend(b) # 4. Asterisk operator *

l_4 = [*a, *b] # 5. Itertools.chain()

import itertools

l_5 = list(itertools.chain(a, b)) # 6. List comprehension

l_6 = [el for lst in (a, b) for el in lst]

Output:

'''

l_1 --> [1, 2, 3, 4, 5, 6]

l_2 --> [1, 2, 3, 4, 5, 6]

l_3 --> [1, 2, 3, 4, 5, 6]

l_4 --> [1, 2, 3, 4, 5, 6]

l_5 --> [1, 2, 3, 4, 5, 6]

l_6 --> [1, 2, 3, 4, 5, 6] '''

What’s the best way to concatenate two lists?

If you’re busy, you may want to know the best answer immediately. Here it is:

To concatenate two lists l1, l2, use the l1.extend(l2) method which is the fastest and the most readable.

To concatenate more than two lists, use the unpacking (asterisk) operator [*l1, *l2, ..., *ln].

You’ll find all of those six ways to concatenate lists in practical code projects so it’s important that you know them very well. Let’s dive into each of them and discuss the pros and cons.

1. List Concatenation with + Operator

If you use the + operator on two integers, you’ll get the sum of those integers. But if you use the + operator on two lists, you’ll get a new list that is the concatenation of those lists.

l1 = [1, 2, 3]

l2 = [4, 5, 6]

l3 = l1 + l2

print(l3)

Output:

[1, 2, 3, 4, 5, 6]

The problem with the + operator for list concatenation is that it creates a new list for each list concatenation operation. This can be very inefficient if you use the + operator multiple times in a loop.

Performance:

How fast is the + operator really? Here’s a common scenario how people use it to add new elements to a list in a loop. This is very inefficient:

import time start = time.time() l = []

for i in range(100000): l = l + [i] stop = time.time() print("Elapsed time: " + str(stop - start))

Output:

Elapsed time: 14.438847541809082

The experiments were performed on my notebook with an Intel® Core™ i7-8565U 1.8GHz processor (with Turbo Boost up to 4.6 GHz) and 8 GB of RAM.

I measured the start and stop timestamps to calculate the total elapsed time for adding 100,000 elements to a list.

The result shows that it takes 14 seconds to perform this operation.

This seems slow (it is!). So let’s investigate some other methods to concatenate and their performance:

2. List Concatenation with append()

The list.append(x) method—as the name suggests—appends element x to the end of the list. You can read my full blog tutorial about it here.

Here’s a similar example that shows how you can use the append() method to concatenate two lists l1 and l2 and store the result in the list l1.

l1 = [1, 2, 3]

l2 = [4, 5, 6]

for element in l2: l1.append(element)

print(l1)

Output:

[1, 2, 3, 4, 5, 6]

It seems a bit odd to concatenate two lists by iterating over each element in one list. You’ll learn about an alternative in the next section but let’s first check the performance!

Performance:

I performed a similar experiment as before.

import time start = time.time() l = []

for i in range(100000): l.append(i) stop = time.time() print("Elapsed time: " + str(stop - start))

Output:

Elapsed time: 0.006505012512207031

I measured the start and stop timestamps to calculate the total elapsed time for adding 100,000 elements to a list.

The result shows that it takes only 0.006 seconds to perform this operation. This is a more than 2,000X improvement compared to the 14 seconds when using the + operator for the same problem.

While this is readable and performant, let’s investigate some other methods to concatenate lists.

3. List Concatenation with extend()

You’ve studied the append() method in the previous paragraphs. A major problem with it is that if you want to concatenate two lists, you have to iterate over all elements of the lists and append them one by one. This is complicated and there surely must be a better way. Is there?

You bet there is!

The method list.extend(iter) adds all elements in iter to the end of the list.

The difference between append() and extend() is that the former adds only one element and the latter adds a collection of elements to the list.

Here’s a similar example that shows how you can use the extend() method to concatenate two lists l1 and l2.

l1 = [1, 2, 3]

l2 = [4, 5, 6]

l1.extend(l2)

print(l1)

Output:

[1, 2, 3, 4, 5, 6]

The code shows that the extend() method is more readable and concise than iteratively calling the append() method as done before.

But is it also fast? Let’s check the performance!

Performance:

I performed a similar experiment as before for the append() method.

import time start = time.time() l = []

l.extend(range(100000)) stop = time.time() print("Elapsed time: " + str(stop - start))

Output:

Elapsed time: 0.0

I measured the start and stop timestamps to calculate the total elapsed time for adding 100,000 elements to a list.

The result shows that it takes negligible time to run the code (0.0 seconds compared to 0.006 seconds for the append() operation above).

The extend() method is the most concise and fastest way to concatenate lists.

But there’s still more…

4. List Concatenation with Asterisk Operator *

There are many applications of the asterisk operator (read this blog article to learn about all of them). But one nice trick is to use it as an unpacking operator that “unpacks” the contents of a container data structure such as a list or a dictionary into another one.

Here’s a similar example that shows how you can use the asterisk operator to concatenate two lists l1 and l2.

l1 = [1, 2, 3]

l2 = [4, 5, 6]

l3 = [*l1, *l2]

print(l3)

Output:

[1, 2, 3, 4, 5, 6]

The code shows that the asterisk operator is short, concise, and readable (well, for Python pros at least). And the nice thing is that you can also use it to concatenate more than two lists (example: l4 = [*l1, *l2, *l3]).

But how about its performance?

Performance:

You’ve seen before that extend() is very fast. How does the asterisk operator compare against the extend() method? Let’s find out!

import time l1 = list(range(0,1000000))

l2 = list(range(1000000,2000000)) start = time.time()

l1.extend(l2)

stop = time.time() print("Elapsed time extend(): " + str(stop - start))

# Elapsed time extend(): 0.015623092651367188 start = time.time()

l3 = [*l1, *l2]

stop = time.time() print("Elapsed time asterisk: " + str(stop - start))

# Elapsed time asterisk: 0.022125720977783203

I measured the start and stop timestamps to calculate the total elapsed time for concatenating two lists of 1,000,000 elements each.

The result shows that the extend method is 32% faster than the asterisk operator for the given experiment.

To merge two lists, use the extend() method which is more readable and faster compared to unpacking.

Okay, let’s get really nerdy—what about external libraries?

5. List Concatenation with itertools.chain()

Python’s itertools module provides many tools to manipulate iterables such as Python lists. Interestingly, they also have a way of concatenating two iterables. After converting the resulting iterable to a list, you can also reach the same result as before.

Here’s a similar example that shows how you can use the itertools.chain() method to concatenate two lists l1 and l2.

import itertools l1 = [1, 2, 3]

l2 = [4, 5, 6]

l3 = list(itertools.chain(l1, l2))

print(l3)

Output:

[1, 2, 3, 4, 5, 6]

The result is the same. As readability is worse than using extend(), append(), or even the asterisk operator, you may wonder:

Is it any faster?

Performance:

You’ve seen before that extend() is very fast. How does the asterisk operator compare against the extend() method? Let’s find out!

import time

import itertools l1 = list(range(2000000,3000000))

l2 = list(range(3000000,4000000)) start = time.time()

l1.extend(l2)

stop = time.time() print("Elapsed time extend(): " + str(stop - start))

# Elapsed time extend(): 0.015620946884155273 start = time.time()

l3 = list(itertools.chain(l1, l2))

stop = time.time() print("Elapsed time chain(): " + str(stop - start))

# Elapsed time chain(): 0.08469700813293457

I measured the start and stop timestamps to calculate the total elapsed time for concatenating two lists of 1,000,000 elements each.

The result shows that the extend() method is 5.6 times faster than the itertools.chain() method for the given experiment.

Here’s my recommendation:

Never use itertools.chain() because it’s not only less readable, it’s also slower than the extend() method or even the built-in unpacking method for more than two lists.

So let’s go back to more Pythonic solutions: everybody loves list comprehension…

6. List Concatenation with List Comprehension

List comprehension is a compact way of creating lists. The simple formula is [ expression + context ].

• Expression: What to do with each list element?
• Context: What list elements to select? It consists of an arbitrary number of for and if statements.

The example [x for x in range(3)] creates the list [0, 1, 2].

Need a refresher on list comprehension? Read this blog tutorial.

Here’s a similar example that shows how you can use list comprehension to concatenate two lists l1 and l2.

l1 = [1, 2, 3]

l2 = [4, 5, 6]

l3 = [ x for lst in (l1, l2) for x in lst ]

print(l3)

Output:

[1, 2, 3, 4, 5, 6]

What a mess! You’d never write code like this in practice. And yet, tutorials like this one propose this exact same method.

The idea is to first iterate over all lists you want to concatenate in the first part of the context lst in (l1, l2) and then iterate over all elements in the respective list in the second part of the context for x in lst.

Do we get a speed performance out of it?

Performance:

You’ve seen before that extend() is very fast. How does the asterisk operator compare against the extend() method? Let’s find out!

import time l1 = list(range(4000000,5000000))

l2 = list(range(6000000,7000000)) start = time.time()

l1.extend(l2)

stop = time.time() print("Elapsed time extend(): " + str(stop - start))

# Elapsed time extend(): 0.015620946884155273 start = time.time()

l3 = [ x for lst in (l1, l2) for x in lst ]

stop = time.time() print("Elapsed time list comprehension: " + str(stop - start))

# Elapsed time list comprehension: 0.11590242385864258

I measured the start and stop timestamps to calculate the total elapsed time for concatenating two lists of 1,000,000 elements each.

The result shows that the extend() method is an order of magnitude faster than using list comprehension.

Summary

To concatenate two lists l1, l2, use the l1.extend(l2) method which is the fastest and the most readable.

To concatenate more than two lists, use the unpacking operator [*l1, *l2, ..., *ln].

Want to use your skills to create your dream life coding from home? Join my Python freelancer webinar and learn how to create your home-based coding business.

Click: How to Become a Python Freelancer?

 

By Mike Wuerthele
Monday, March 09, 2020, 08:48 pm PT (11:48 pm ET)

Apple is doubling-down again on health and fitness in its operating systems, and appears to be building an app to help users walk through different workouts, and perform them safely.

The app, reportedly called “Seymour,” looks to be a separate app from the Activity app. At present, it looks like it will be launched alongside iOS 14, watchOS 7, and tvOS 14. It isn’t clear how much data the two apps will pass between each other at this time.

“Seymour” is said to allow users to download fitness videos, with specific guidance provided on how to get proper credit for completion on the Apple Watch. While the download can be triggered on the Apple Watch, it appears that a larger screen, such as a television with an Apple TV, an iPad, or iPhone will be required to view the videos —which makes sense, given the size of the Apple Watch screen.

According to MacRumors who spotted the app on Monday night, workouts included are core training, cycling, strength training, some form of dance, yoga, and indoor running.

At present, there does not appear to be a monetization path for the videos. There are no in-app purchases or subscription fees currently associated with the training materials.

As with the previous PencilKit and Message improvement reports, it isn’t precisely clear when the features may roll out. They may or may not make a potential early June beta release during the annual WWDC —which is in question because of the ongoing coronavirus situation.