Recently WordPress released version 4.6 and it had one Nasty surprise for me…… contact-forms suddenly didn’t work anymore.
Because this happened when I was handing over a website to a customer, I was wondering whether i had made a typo…

I hadn’t.

The wp_mail() function, which is being used by almost everything that wants to send emails from a WordPress website, according to the change log has been changed.

In 4.6 (see r38058) we changed how we apply the from email and name, we now use PHPMailers own setFrom()function call.

Sadly it has proven to be buggy. The good news is that it has been solved and a correct working function will be released with 4.6.1.

Until you can implement the 4.6.1. release in production, here’s the quickfix that solves your problem for now, however with a downside; you won’t be able to send attachements.

For Contactform 7:

I changed the wp_mail() function to mail() and removed $attachments. This is working for my setup with contact-form-7 4.5 and wordpress 4.6. Obviously without attachments.

see /wp-content/plugins/contact-form-7/includes/mail.php (Line 85)

old:

 return wp_mail( $recipient, $subject, $body, $headers, $attachments );

new:

return mail( $recipient, $subject, $body, $headers );

Change it back once you have implemented 4.6.1. and verified that it works as expected.

Hope this helps

R.

There are a couple of Open Source MFA solutions available and for the ease of installation and use I choose to use Google Authenticator.

In part 1 of this tutorial we installed google authenticator on a Redhat/Centos based or Debian/Ubuntu based linux VM. In this second part of the tutorial we are going to link your softtoken to the authenticator service on the linux vm. As a optional bonus I will show how you can prevent having 1 softtoken per VM for every installation in your Cloud environment.

STEP 3: Create the Google Authenticator connection for your account.

You can activate the google-authenticator for the root user or any other user. Switch to the user who should use the two-factor authentication and type in:

google-authenticator

You will be prompted to answer a few questions; answer the first two questions with yes (y):

Do you want authentication tokens to be time-based (y/n) y

Do you want me to update your "/home/USERNAME/.google_authenticator" file (y/n) y

You can answer the next questions according to your needs.

You can use the Google Authenticator app to scan the qr-code, or add the account using the secret key and the verification code. Do not forget to print out the emergency scratch codes and store them in a safe place!

STEP 4: Create the Google Authenticator connection for your account.

To use the module you have to edit the pam, and sshd config files.

vi /etc/pam.d/sshd

Add the following line on top of the file:

auth required pam_google_authenticator.so

One more file to edit:

vi /etc/ssh/sshd_config

Find and change the following line:

ChallengeResponseAuthentication yes

STEP 5: Restart your SSH service and test the configuration.

Now switch back to root and restart the SSH server. If you added the two-factor authentication for the root user you can skip the next step.

su root

Finally restart the SSH server.

/etc/init.d/ssh restart

That’s it! You should now have a SSH server with an two-factor authentication! Test this by opening up a new ssh session to the server, and verify that you can get in before closing out your current ssh session.

Coming soon

In the last part of this Tutorial, we will show you how to deploy Google Authenticator configuration for your user(s) and how to prevent having to use a differend authenticator for every server you want to access.

How Does Docker Work?

Before we start with the installation it’s good to know a little bit about how Docker works. Docker has a client-server architecture. Docker Daemon or server is responsible for all the actions that are related to containers. The daemon receives the commands from the Docker client though cli or REST API’s. Docker client can be on the same host as daemon or it can be present on any other host. Images are the basic building blocks of Docker. Containers are built from images. Images can be configured with applications and used as a template for creating containers. Images are organized in a layered manner. Every change in an image is added as layer on top of it.

Docker registry is a repository for Docker images. Using Docker registry, you can build and share images with your team. A registry can be public or private. Docker Inc provides a hosted registry service called Docker Hub. It allows you to upload and download images from a central location. If your repository is public, all your images can be accessed by other Docker hub users. You can also create a private registry in Docker Hub. Docker hub acts like git, where you can build your images locally in your laptop, commit it and then can be pushed to the Docker hub.

Docker containers are created from images. It is a writable layer of the image. You can package your applications in a container, commit it and make it a golden image to build more containers from it. Two or more containers can be linked together to form tiered application architecture. Containers can be started, stopped, committed and terminated.

The best feature of Docker is collaboration. Docker images can be pushed to a repository and can be pulled down to any other host to run containers from that image. Moreover Docker hub has thousands of images created by users and you can pull those images down to your hosts based on your application requirements.

Installation of Docker

As said, Docker can be installed on several types of environments. ranging from Linux, via Apple’s OSX to Microsofts Azure and Windows 10. A ready environment can be obtained from Amazon AWS, Google Cloud Platform, Microsoft Azure, and a number of independent cloud providers like Digital Ocean and Rackspace. This tutorial will show how to install Docker and optionally Docker Compose on Debian and Redhat Enterprise based Linux Distributions.

Step 1: Add the repository

Debian based:

# docker requires apt-transport-https
sudo apt-get install apt-transport-https -y
# get the docker key for the docker registry
sudo apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D
# add the repository
sudo echo "deb https://apt.dockerproject.org/repo debian-jessie main" | \
sudo tee /etc/apt/sources.list.d/docker.list

RHEL based:

$ sudo tee /etc/yum.repos.d/docker.repo <<-'EOF'
[dockerrepo]
name=Docker Repository
baseurl=https://yum.dockerproject.org/repo/main/centos/$releasever/
enabled=1
gpgcheck=1
gpgkey=https://yum.dockerproject.org/gpg
EOF

STEP 2: Install the service on your Linux machine.

Debian based:

# Install the Docker engine
sudo apt-get update && sudo apt-get -y install docker-engine
# Start the docker service
sudo service docker start

RHEL based:

#Install the Docker engine
sudo yum install docker-engine
# Start the docker service
sudo service docker start

STEP 3: Create a Docker group to prevent use of the root user.

Debian based:

#The group docker should be created during installation, but can be done like this
sudo groupadd docker
#add the users that manage the docker containers to the group
sudo adduser $USER docker

RHEL based:

#The group docker should be created during installation, but can be done like this
sudo groupadd docker
#add the users that manage the docker containers to the group
sudo usermod -aG docker your_username

STEP 4: Install Docker compose (optional, only in DEV environments

Docker Compose applications are easy to share with your teams. You just need to define your application with Docker Compose once and use that same configuration to run the application on other machines to save your time.

Debian based:

To install Docker compose, we need to install the python-pip package as a prerequisite before installing the docker-compose.

sudo apt-get install python-pip

After that, you are ready to install docker-compose by running the below command in your command line terminal.

#Install Docker Compose
sudo pip install docker-compose

RHEL based:

On RedHat based systems, you will need to install epel-release and php-pip

sudo yum install -y epel-release python-pip

After that, you are ready to install docker-compose by running the below command in your command line terminal.

#Install Docker Compose
sudo pip install docker-compose

To run docker-compose successfully you will need to upgrade the php packages.

sudo yum upgrade python*

Now you have successfully installed docker-compose, docopt, requests, texttable and few other packages, and are able to compose docker contained applications. You are also able to run docker containers from a non-privileged account.
Hope this helps

Your Data, Your Responsibility, Our Business

There are a couple of Open Source MFA solutions available and for the ease of installation and use I choose to use Google Authenticator.

This tutorial contains configuration instructions for both Debian and Redhat based Linux distributions and are written for the current versions.

What is Google Authenticator and how does it work?

Google Authenticator is an alternative to SMS for 2Step verification, installing an app on Android / IOS  where the codes will be sent. It supports both the HOTP and TOTP algorithms for generating one-time passwords.

With HOTP, the server and client share a secret value and a counter, which are used to compute a one time password independently on both sides. Whenever a password is generated and used, the counter is incremented on both sides, allowing the server and client to remain in sync.

TOTP essentially uses the same algorithm as HOTP with one major difference. The counter used in TOTP is replaced by the current time. The client and server remain in sync as long as the system times remain the same. This can be done by using the Network Time protocol.

The secret key (as well as the counter in the case of HOTP) has to be communicated to both the server and the client at some point in time. In the case of Google Authenticator, this is done in the form of a QRCode encoded URI. See: KeyUriFormat for more information.

How do I install Google Authenticator?

The installation contains of 5 steps:

STEP 1: Install the Client on a mobile device.

First the Google Authenticator app has to be installed on a mobile device:
Android: Get the latest version here, directly from Google Play.
IOS: Get the latest version here, directly from the App Store.
Windows: There is no GA app, but a compatible app can be obtained here, from the Microsoft App store

STEP 2: Install the service on your Linux machine.

Debian based:

You will install all dependencies like NTP automatically using the -y switch

sudo apt-get -y install libpam-google-authenticator

RHEL based:

First we need to install the development tools so we have a compiler, and the libraries we need. To do that we’ll use yum to install the “Development Tools” group

sudo yum -y groupinstall "Development Tools"

Now we need to install the pam development package

sudo yum -y install pam-devel

We setup and enable ntp so we can make sure our time is correct. Since we will be using a time based sync.

sudo yum -y install ntp
sudo systemctl start ntpd
sudo systemctl enable ntpd

Now we can download the google authenticator pam module from code.google.com, we will download it to /opt.

cd /opt
wget https://google-authenticator.googlecode.com/files/libpam-google-authenticator-1.0-source.tar.bz2

Unzip, untar, compile the module, and install it.

bunzip2 libpam-google-authenticator-1.0-source.tar.bz2
tar -xvf libpam-google-authenticator-1.0-source.tar
rm -f libpam-google-authenticator-1.0-source.tar
cd libpam-google-authenticator-1.0
make

When the compilation is successfully completed, Google Authenticator can be installed. (note: this has to be done by a privileged user)

sudo make install

Now you have installed Google Authenticator

In the next part of this Tutorial, We will show you how to setup the Google Authenticator and how you can prevent having to use a different authenticator for every server you want to access.

https://techgourmet.net/enable-multi-factor-authentication-google-authenticator-part-2

Why am I only able to create partitions up to a total of 2TB on bigger harddisks?

The answer is simple. I was using ‘fdisk’. Fdisk is an old tool which uses a 32-bit ms-dos partition table. Subsequently, the Master Boot Record (MBR), in which the partition begin and end-points are stored is 32 bit, and thereby it can’t handle anything above 2 TeraBytes.

So how do we avoid using fdisk and create partitions larger 2TB in linux

To fully use your 2+TB harddrive, you have to use a partition table that supports it. We now know that the MS-DOS partition table (MBR) does not, so what should you use instead? GPT.

GPT supports up to 9.4 ZB (ZetaByte). That’s 9895604649984 GB (GigaByte)!. It’s pretty safe to say, that you will not hit this limit in the near future.

Requirements

First make sure that you have a backup of all your data thats on the harddrive, somewhere else. Because what you have to do WILL wipe the drive clean, and delete everything on it!

You need a program called “parted”. It’s the easiest way to create the partition table and create a partition of the desired size. It might be installed already on your Linux system. If not then you have to install it using your favorite package manager.
In debian that would be:

apt-get install parted

In RedHat EL/CentOS that would be:

yum install parted

Identify your harddrive

You have to find out what your harddrives name is.
In Linux, every harddrive get’s a name. This can be “sda”, “hda” or something similar depending on what kind of interface they are connected to.

Find your drive names using the following tools:
lsblk
fdisk

Run the command:

lsblk

And you should see something like the following:

You see how there is a “sda” and a “sdb” ?

If you notice the nice treeview lsblk makes, you will see that below “sda” there is “sda1″ and “sda2″. These are partitions on disk “sda”
sdb has a partition too, because I already formatted my harddrive to 4TB, but before I formatted it with a GPT partition table, “sdb1″ only had 1.8TB under the column “SIZE” which is the same problem you have.

Now we need to find the maximum size of your harddrive. You can do this by using the program “fdisk” with the following syntax:

fdisk -l /dev/<your harddrive name here>

In my example it would be:

fdisk -l /dev/sdb

You will get an output that looks something similar to this, it’s the top line marked with the number of GB we are interested in:

Disk /dev/sdb: 4000.8 GB, 4000787030016 bytes
255 heads, 63 sectors/track, 486401 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Disk identifier: 0x00000000
Disk /dev/sdb doesn't contain a valid partition table

The “4000.8 GB” is the size of your harddrive, and this will be the max size of any partition. note this number, you will need it later.

Creating the partition table

Run the program you installed earlier in this guide called “parted” by running the following command:

parted /dev/<your harddrive name here>

In my case, the example would be:

parted /dev/sdb

The output will look like this:

GNU Parted 2.3
Using /dev/sdb
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted)

Create the GPT partition table

Type in the following and hit enter to create a GPT partition table:

mklabel gpt

The output will look like this, after you types “yes” and pressed enter to the warning stating that this will delete all files on the harddrive:

Warning: The existing disk label on /dev/sdb will be destroyed and all data on this disk will be lost. Do you want to continue?
Yes/No? yes
(parted)

Set the unit to GB

Now set the unit to GB to make it easy to specify the partition size later on. Type the following and hit enter. This will not give any output:

unit GB

Create the partition

To create the partitoion, you simply type the following syntax and press enter:

mkpart primary <from GB> <to GB>

In my example with the 4TB (4000GB) harddrive, this would be:

mkpart primary 0.0GB 4000.8GB

The above command will not give you any output.

View the partition table

To view the partition table and partition you just created, type the following and press enter:

print

Sample output:

Model: ATA WDC WD40EFRX-68W (scsi)
Disk /dev/sdb: 4001GB
Sector size (logical/physical): 512B/4096B
Partition Table: gpt

Number  Start   End     Size    File system  Name     Flags
 1      0.00GB  4001GB  4001GB  ext4         primary

You see the partition and the size you just created.

Now type the following and hit enter to save and quit parted:

quit

Create the filesystem

There are many filesystems to choose from. I prefer ext4 and that is what I will use in this guide. For general purpose, ext4 should be just fine. If you need to use the harddrive for something special, then please read up on what filesystem would be best for you and use that instead.

If you run the “lsblk” command again like earlier in this guide, you should now have a “1″ partition like I did in my example: “sdb1″

Creating a ext4 filesystem takes some time. my 4TB disk took ~40 minutes to format.

Create the ext4 filesystem using the following command:

mkfs.ext4 /dev/<your drivename and partition number here>

In my example it would be:

mkfs.ext4 /dev/sdb1

Wait for it to finish creating all the inodes, the finished output should look something like this:

mkfs.ext4 /dev/sdb1
mke2fs 1.41.12 (17-May-2010)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
183148544 inodes, 732566272 blocks
36628313 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=4294967296
22357 block groups
32768 blocks per group, 32768 fragments per group
8192 inodes per group
Superblock backups stored on blocks:
        32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208,
        4096000, 7962624, 11239424, 20480000, 23887872, 71663616, 78675968,
        102400000, 214990848, 512000000, 550731776, 644972544
Writing inode tables: done
Creating journal (32768 blocks): done
Writing superblocks and filesystem accounting information: done
This filesystem will be automatically checked every 31 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.

Add the partition to fstab and mounting it

Adding the partition to fstab will make it auto remount upon reboot of the computer/server.

But first create the folder where you want the partition to be mounted. In my example I will use /store:

mkdir /disk/partition

open the file /etc/fstab in your favorite text editor and add the following line at the bottom:

/dev/<your drivename and partition number>               /partition                  <your filesystem>    defaults        0 0

In my example it would be:

/dev/sdb1              /disk/partition                  ext4    defaults        0 0

Mount the partition

Mounting the partition is now as easy as typing the following command:

mount /disk/partition

Because you added the mount point to fstab, this will automatically happen upon reboot and only has to be done this one time.

Hope this helps