Krishna's Webplace

Ubuntu Server Setup Part 2: Installing Nextcloud

Sat, 22 Jun 2024 20:35:26 +0530

I finally setup my Ubuntu server quite well along with wifi drivers.

Next up, I had to install Nextcloud, because I wanted a cloud storage that could backup and sync photos, videos and other stuff from several devices at my home. Thus I looked up a tutorial on it and found one by Jay, which was extremely easy to follow and helped me setup my Nextcloud instance from scratch.

The steps to do the same are as follows:

You should be using a normal user account, and should not be executing the commands as ‘root’. In case you are ‘root’, simply execute the following:
```
adduser <Enter your desired username here>
usermod -aG sudo <Enter the username you set above>
```
Update the system’s cache and also apply any pending updates with the following command:
```
sudo apt update && sudo apt dist-upgrade
```

Now, let us download and install php, mariadb and apache (along with some additional dependencies and required packages):

sudo apt install libmagickcore-6.q16-6-extra php php-apcu php-bcmath php-cli php-common php-curl
php-gd php-gmp php-imagick php-intl php-mbstring php-mysql php-zip php-xml apache2 unzip 
mariadb-server redis-server php-redis -y

Note: You can check if apache is running [Should be active and enabled] with:

systemctl status apache2

Download and unzip nextcloud with:
```
wget https://download.nextcloud.com/server/releases/latest.zip
unzip latest.zip
```
We will now change the ownership of nextcloud to the group and user ‘www-data’ and move the nextcloud folder into the ‘/var/www/’ directory as SOP. The ‘www-data’ is a user (and group) created by default when we installed apache2. The -R flag changes ownership of all files and folders within the nextcloud directory recursively.
```
sudo chown www-data:www-data -R nextcloud
sudo mv nextcloud /var/www/
```
PHP needs some modules to be enabled for it’s functioning. Do so with:
```
sudo phpenmod imagick intl bcmath gmp  
```
Let us start configuring database, which is required to base our Nextcloud on. We must first run a setup of mysql to secure our installation. To do so, run:
```
sudo mysql_secure_installation
```
It will open a console asking you to fill certain details.
- The first prompt will be asking for default root password, just press Enter button to skip this option.
- Next it will ask for Unix socket, type ‘n’ and proceed.
- Then it will ask to enter a password, type ‘y’ and then enter a password (store it securely).
- Just keep pressing Enter button to skip through rest of the options (Capital letter means default option, ‘Y’ in all these options).
Once done with this, we must now configure mariadb. Open it’s shell by:
```
sudo mariadb
```
In this shell, type these commands (replace where marked):
- CREATE DATABASE nextcloud;
- GRANT ALL PRIVILEGES ON nextcloud.* TO ‘nextcloud’@‘localhost’ IDENTIFIED BY <‘Enter a secure password here for the db. Do keep the password inside single inverted commas.'>;
- FLUSH PRIVILEGES;
- exit;
NOTE: Store this password very securely, as it can be misused if leaked.
We should now generate our own SSL/TLS certificate to use with our server (In case you have a static IP, you should use Let’s encrypt’s certificate using Certbot)

NOTE: This command will ask you several question. Answer whatever you want to fill in (won’t have much effect).
```
mkdir $HOME/certs && cd $HOME/certs/

openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 3650 -nodes
```
NOTE: Please store both the key.pem and cert.pem somewhere secured. Also import cert.pem as an Authorities certificate in your browser to avoid the browser from flagging our nextcloud instance as a ‘Not Secure’ website everytime we visit it.

Now we must disable the default webpage of apache, place our config file in the apache directory and enable the config for apache to load the nextcloud page (Along with adding Strict Transport Security).

sudo a2dissite 000-default.conf

sudo nano /etc/apache2/sites-available/nextcloud.conf

In the text editor which opens, paste the following code:

<VirtualHost *:80>

    RewriteEngine On
    RewriteCond %{SERVER_PORT} !443
    RewriteRule ^(/(.*))?$ https://%{HTTP_HOST}/$1 [R=301,L]

</VirtualHost>

<VirtualHost *:443>               
    DocumentRoot "/var/www/nextcloud"

    SSLCertificateFile $HOME/certs/cert.pem
    SSLCertificateKeyFile $HOME/certs/key.pem
    SSLEngine on


    <Directory "/var/www/nextcloud/">
        Options MultiViews FollowSymlinks
        AllowOverride All
        Order allow,deny
        Allow from all
    </Directory>

    TransferLog /var/log/apache2/nextcloud_access.log
    ErrorLog /var/log/apache2/nextcloud_error.log

    <IfModule mod_headers.c>
        Header always set Strict-Transport-Security "max-age=15552000; includeSubDomains"
    </IfModule>
</VirtualHost>

Save this file by doing ctrl+o and ctrl+x. Then enable this config file using:

sudo a2ensite nextcloud.conf

Let us tune PHP to make our server run more efficiently:

Note: PHP versions can differ on different distributions, like 8.3 on Ubuntu 24 LTS and 8.1 on 22 LTS, thus press tab as directed below:
```
sudo nano /etc/php/<press tab to autocomplete here>/apache2/php.ini
```
Find and edit the file by change stuff inside it according to this (Replace the areas where you see fit. To remove a comment, remove the ‘;’ semi-colon in front of the line in the file):
- memory_limit = 2G
- upload_max_filesize = 20G
- max_execution_time = 360
- post_max_size = 20G
- date.timezone = Asia/Kolkata
- opcache.enable=1
- opcache.interned_strings_buffer=16
- opcache.max_accelerated_files=10000
- opcache.memory_consumption=128
- opcache.save_comments=1
- opcache.revalidate_freq=1
Some modules are required by apache2, so enable them for use with nextcloud.
```
sudo a2enmod dir env headers mime rewrite ssl
```
Enable the apcu module in php. This module caches data in memory, so helps in reducing database queries and file system operations. This also allows the occ script to function.

Note: PHP versions can differ on different distributions, like 8.3 on Ubuntu 24 LTS and 8.1 on 22 LTS, thus press tab as directed below:
```
echo "apc.enable_cli=1" | sudo tee -a /etc/php/<press tab here>/mods-available/apcu.ini
```
Finally, let us restart apache2 to get nextcloud working:
```
sudo systemctl restart apache2
```

Create an administrator account in the webpage that opens when you visit the IP address / URL that you attached to the server. Then when you scroll down, it will ask for your database details. Fill according to what you entered in the above steps (db account and name should be ‘nextcloud’ and password will be the one you entered while configuring mariadb, step 7).

Sign in and setup nextcloud as you like. Next, head over to the Admin settings by clicking on your profile on top right side and then on “Administration settings”.

In here, you will see the various issues that nextcloud has automatically detected with the installation. I cannot give solutions to all the issues present over there, but some of them which I had faced personally are as follows:

If you get a very big error which states that the database is missing some indices, simply do as follows:

sudo chmod +x /var/www/nextcloud/occ                                      

sudo -u 'www-data' /var/www/nextcloud/occ db:add-missing-indices          

sudo chmod -x /var/www/nextcloud/occ

This adds the missing indices using occ script provided by nextcloud themselves, which helps in correcting issues with nextcloud.

Enable memory caching:
```
sudo nano /var/www/nextcloud/config/config.php
```
In the text editor which opens, add the following line somewhere in between the other lines (before the closing bracktes atleast):
- ‘memcache.local’ => ‘\OC\Memcache\APCu’,
- ‘default_phone_region’ => ‘IN’,
NOTE: Replace phone region code to whatever your region code is. Also, remember to have those commas in the end of each of the above 2 lines.
Additional security parameter is to lock down the config.php file to root group, as it contains sensitive information like our database password.
```
sudo chmod 660 /var/www/nextcloud/config/config.php

sudo chown root:www-data /var/www/nextcloud/config/config.php
```

After doing this much, you can restart apache and/or even reboot your system once.

Now I think you will be good to go with your own personal cloud storage. Remember to keep your system updated and files backed up (like 3-2-1 rule) to be safe.

Whatsapp Without Phone

Wed, 29 May 2024 20:43:23 +0530

Yes, whatsapp without it’s app on phone, you read it right.

I had stopped using whatsapp because I didn’t want to have it’s “proprietary” app on my degoogled device.

But you see, this application is used by most of my academic professors and other colleages, so I had to somehow use it (without the app on my phone, of course).

So I thought of running it through some android emulator, but didn’t want to natively run it on my linux machine.

Thus I installed Windows 10 through virtual box and then installed bluestacks in it. But bluestacks was not starting properly (issues with virtualization).

Had to enable the following 2 options to get virtualization working:

If this still doesn’t work for you, I think you should also enable Virtualization and Hyper-V support from “Turn on windows features” from within your Windows VM.

After this, bluestacks started working normally and I installed whatsapp normally in it and logged in to my account [A strange thing was that all my chats and groups were gone, but maybe that was because I was logging in after around 1 month].

My next major work was to get whatsapp web working, so that I could use it on my other devices (of course, not going to run the emulator each time I have to use it).

To do so, whatsapp requires web versions to have their QR code scanned by the whatsapp application for login, thus I used a usb camera that I had with me, but I got this error when I tried to use the webcam in my Windows VM:

It required a bit of work to implement a “Webcam Passthrough”, so that the VM instance could access the USB camera.

The steps were as follows [Credits]:

First install certain extra packages to get stuff working:

sudo apt-get install virtualbox-guest-additions-iso virtualbox-ext-pack

Next, we need to find our webcam details using this:
```
VBoxManage list webcams
```
This should show us a list of (for me only 1) webcam/s attached to your host device.
Now finally we need to connect this webcam to enable passthrough. Issue this command, by replacing the word Windows with the name of your VM instance and the .1 with the number that corresponds to your webcam as listed in step 2 (in most cases, it should be .1):

NOTE: This command must be run only when your windows VM is running.
```
VBoxManage controlvm "Windows" webcam attach .1
```

NOTE: If you shutdown or restart your VM, it will loose access to the camera. You need to re-run the step 3 command to get it working.

With this much, my VM was able to detect the webcam and without much difficulty, I was able to register with the whatsapp web version on my devices.

A small caveat though, remember to open the whatsapp in your windows VM every 14 days to avoid getting logged out of your whatsapp web devices.

Sign a Custom ROM Build

Sun, 26 May 2024 21:05:20 +0530

This guide will explain how to sign a Custom ROM build (typically unofficial builds, as most official ROMs are now shipping their own private keys).

I will use the Lineage wiki guide, but simplify it in my own words at places where I feel this guide did not give more practical information to a new comer like me.

The steps to Generate the keys are as follows:

NOTE: You only need to run this once. If you ever rerun these, you’ll need to migrate between builds.

Go to the directory where all yours rom files are originally synced (the root of your custom rom files). Now open a terminal and issue this command:

NOTE: Please note this beforehand that running the following code will ask you to enter password for several keys and several number of times. I will say that just enter 1 password and copy+paste it on all the places where it asks for a password to be entered.

DO NOTE THIS PASSWORD DOWN, as we will have to use it when we sign the builds.
```
subject='/C=US/ST=California/L=Mountain View/O=Android/OU=Android/CN=Android/emailAddress=android@android.com'
mkdir ~/.android-certs
for cert in bluetooth cyngn-app media networkstack platform releasekey sdk_sandbox shared testcert testkey verity; do \
    ./development/tools/make_key ~/.android-certs/$cert "$subject"; \
done
```

Now we need are required to re-sign APEX keys. To do so, simply run the following:

cp ./development/tools/make_key ~/.android-certs/
sed -i 's|2048|4096|g' ~/.android-certs/make_key

Now finally, we must generate our keys. I will strongly recommend you to generate them with a password (re-use the password you used in step 1).

The command to run is in here

NOTE: If you have issues following up with these steps, I have a script that will execute the commands for you (of course, you have to manually enter the password for each keys). You can find that script here

Usage (copy paste this in terminal):
```
curl -O https://raw.githubusercontent.com/ObsidianMaximus/scripts/master/signing/Generate_Keys.sh
bash Generate_Keys.sh
```

Now, the steps to make a .zip flashable package are as follows:

Source the envsetup.sh by executing this command:
```
source build/envsetup.sh
```
Now finally, we will have to start compiling the files for our custom ROM (this will take a long time, depending on your computer’s specs). To do so, run the following command (replacing the codename with your device codename):
```
breakfast <codename>
mka target-files-package otatools
```
Now, it is time to sign all of our APKs and APEXes and build the .zip package.

We will use 2 environment variables to ease our task, as they will allow us to sign without having to enter the password several times. For that, we must issue these 2 commands in the terminal:
```
export ANDROID_PW_FILE=/path/to/your/password/file
export EDITOR=your_preferred_text_editor
```
NOTE: Replace the fields above as required. For the ANDROID_PW_FILE, just create a file somewhere and input its path there. As for the EDITOR variable, choose whichever editor you like (eg. vim, nano, codium, etc).

Next run the following commands to call the script to start signing:
```
curl -O https://raw.githubusercontent.com/ObsidianMaximus/scripts/master/signing/Sign.sh
bash Sign.sh
```
NOTE: This script will invoke a command “sign_target_files_apks”, which should open the editor which you specified above, but if it does not, then open the file that you had given above in “ANDROID_PW_FILE” and you should have stuff inside of it with empty spaces in these “[[[ ]]]” brackets.

Fill the password in this empty space for all the apks [make sure to fill it between the 3 left and 3 right brackets], and then save this file, and re-run the above script by simple doing: bash Sign.sh.

NOTE: Wait patiently, it can take some time to do all of the above process.

Congratulations, you have successfully signed the build. Now in case you are wondering where the .zip file is (no, it is not in the usual out/ directory), the .zip is right in the android root tree, where you issued the commands from.

Just clean flash the signed-ota_update.zip and device integrity should be met now.

Update: Just confirmed that dirty flashing this build over the previous unsigned ROM also works!

Ubuntu Server Setup Part 1

Tue, 30 Apr 2024 19:46:03 +0530

I was wanting to learn on how to setup my servers and host stuff on them, but to host a server online, one needs to spend some amount of money on them, which i really didn’t want to. But then i remembered that i have one old dusty home computer that had been lying in my home since several years, while not really being used anymore.

So i decided to use this opportunity to reuse the same computer for my server tasks and in this way, i will be saving up on those server costs that i would have to pay [electricity is cheap here].

But i had a hurdle in my path, and that was my old monitor not working, due to which i was unable to get my cpu to give a basic display as it had only VGA output. And well, i couldn’t really use this PC with my current monitor, as this monitor supports only HDMI and Display Port. I did have one VGA-to-HDMI converter lying around with me, but that had malfunctioned as well.

This had me worried for some time before i thought of just using the gpu in my current setup on the older one. Sadly, this had another issue. The older desktop is an Intel Pentium E5400, and has a motherboard which is of LGA775 socket type. Now, this motherboard has the onboard power supply cables right above the PCIe slot, which rendered me placing my hefty gpu in that slot useless.

Then i had to think a bit more and got an idea of just taking out the HDD from the old PC and placing it in my working desktop [silly me]. I attached the HDD to my newer PC and started the machine.

At first, i went for the trusted server OS, Debian. Flashed it onto my usb drive and tried live booting only to be suprised with no display. Forgot that i had to enable CSM from BIOS and then turn on “legacy only” mode to allow the usb to boot [had partitioned it as MSDOS/MBR, silly me, again..]. This was again because the older computer had legacy BIOS only and i had to test the current HDD to ensure that it did boot alright under legacy conditions.

Adjusted boot options and booted the PC only to be met by a weirdly enlarged debian graphical installer. Pressed enter and the PC restarted and i was met with just blurred out lines and teared display with the text not legible at all. Tried rebooting several times from my usb drive but was met with the same issue again and again. Finally got quite frustrated and flashed ubuntu server on the drive.

Booted from it and to my surprise, it turned on smoothly. At first the screen was enlarged but when i progressed the installation, it auto-adjusted normally and matched my 24" screen resolution quite well. Installed the ubuntu server, which was pretty straight forward, thanks to the KIS ways of Ubuntu.

Then my next task was getting my wifi modem or should i say TP-Link USB Network Adapter (Archer T2U Plus) in working condition, as i planned to keep the pc in an isolated place. The instructions for the same can be found here. This adapter uses a Realtek RTL8821AU Chipset at its heart, which fortunately has linux drivers available, thanks to aircrack-ng! Executing the commands in the script installed all it’s drivers. Now next, i had to enable it and connect to my home network to make the pc accessible by my other devices.

To do this, here is an excellent guide from Ubuntu!

As for the steps i followed, they were as follow:

Firstly, i had to install network-manager as it was not present by default on the default server installation [ strange? ].
Next, i ran nmcli d command to get the name of the wifi device.
Then, to turn it on, issue: nmcli r wifi on and list all the scanned wifi networks with: nmcli d wifi list
To connect to one of the networks listed, you have to type: nmcli d wifi connect <name of the wifi> password <password for that wifi> [Replace stuff within < > with what you have got listed in the above step.]
It took several seconds but after that it did get connected to my wifi network! I restarted my pc without the ethernet cable and the wifi did indeed work, although on startup, one of the checks done by systemd made me wait for quite a long time, more on that here.

I then took out the HDD and inserted it into my older desktop and sadly, even after it being turned on for several minutes, i had no green led light show up on the wifi usb adapter [which is used to indicate that the modem is in use by the OS], thus, the older pc was not turning on properly and i had no way to get to diagnosing the issue as i just didn’t have a display [running it headless].

I think that i will have to indeed get my monitor repaired to continue on with my experimentations on my newly built home server.

Use SSH or Rsync With Android

Fri, 26 Apr 2024 09:28:58 +0530

Today, i wanted to send a file from my desktop to my android device. I thought of using rsync for this purpose, which is a tool that i use frequently to sync files between my desktop and my laptop.

I thought of giving it a try and came across this great article that explained just this.

NOTE: This guide requires both the computer and the Android device to be on the same wifi network.

The process to send files from PC to Android which i took was as follows:

Install rsync on termux using the command: apt install rsync and install openssh using the command: apt install openssh.
Then setup the internal storage of our Android device to be accessible by termux using the command: termux-setup-storage. Grant termux the permission to access storage when prompted.
Now, change the sshd config file to allow termux to use SSH port. Termux does not have the permission to use the default SSH port 22, so we will use 8022 port instead. For doing this, edit the ../usr/etc/ssh/sshd_config file by simply using the command: echo "Port 8022" >> ../usr/etc/ssh/sshd_config
Let’s get the local ip address of our device by using the command: ifconfig. The ip address should be usually in the end and will be after “inet” . Or you can just go to Settings app and click on wifi and select the wifi you are connected to and look for the ipv4 address. In either of these 2 cases, the ip address should usually begin with 192.168.xx.xx where x’s are to be replaced by your ip address part.
Setup a password for the user by using the command: passwd.
Finally, we have to start the SSH daemon. To do this, enter this in termux: sshd.

For using SSH :

Open terminal on your pc and type: ssh -p 8022 192.168.xx.xx [where the x’s are replaced by your ipv4 address part].
You should now be able to use android terminal through your desktop terminal.

For using Rsync :

Simply enter the command : rsync -e 'ssh -p 8022' <file to transfer from pc> 192.168.xx.xx:/data/data/com.termux/files/home/storage/

Explanation of some stuff in the above commands :
- The -e command is used to specify the remote shell to use. For more details, check the manpage of rsync.
- The x’s replace your ipv4 address parts.
- /data/data/com.termux/files/home/storage/ is the “usual” path of the main storage in our Android which the user can access, so we are sending the file from our desktop to our Android device’s internal storage using this. You can specify some folder to send the file into directly by simply adding the folder after storage/ in the command. If this shows an error message when you try to transfer files, just type: pwd in termux to get your current directory where you wish to send/receive the files and replace output of this command with the path in the step 1 command above after your phone’s ip address.
- This should work in vice-versa as well. Just add the path to copy from Android first and the path to copy to in your desktop after this.

Side Note:

To avoid entering password all the time while accessing SSH/Rsync, generate a key pair on your pc using the command: ssh-keygen and then copy it to Android using the command: ssh-copy-id -p 8022 192.168.xx.xx in your desktop terminal. This will ask you password only once and after authenticating it, you can now just use SSH/Rsync without entering that password which we generated in the “Step 5” in the beginning.
REMEMBER that the ip address of your android device can change from time to time due to ip addresses being dynamic when using wifi. Or they “may” change if the router is restarted. In any case, be sure to repeat the “Step 4” which we did in the beginning to find our local ip address.

Ubuntu Touch Port Part 1

Thu, 25 Apr 2024 13:38:00 +0530

Getting Started

So I recently decided to get more involved in the Android world and came about a ‘new’ type of OS, known as Ubuntu Touch. I thought a bit on it and decided to start the porting process for it for my device Realme GT Neo 2 [codenamed:bitra].

I started with the official documentation of UBports where in they gave some good amount of introduction on how and why certain things needed to be done.

The guide mentions the use of GSI for devices with Android 8+ and, as my device is indeed treble supported, I think I will head to using GSI only.

Standalone Kernel Method (Halium 9 and newer) is very interesting as it seems to be the least tiresome way for porting among all of the 3 mentioned methods. So I started with this and did the steps as mentioned in the guide.

The defconfig that i had to use is the sm8250_defconfig. Next i made a halium.config file as prompted.

Next, i had to fill in the deviceinfo file. For this purpose, I used the Poco X3 Pro device branch as a dummy template and started filling stuff according to it and the guide.

But I got stuck on the deviceinfo_bootimg_prebuilt_dtb step as i was not sure where to find my dtb. So i asked this question in the telegram group of Ubports and was recommended to run a script on the boot.img which i had extracted.

The script was by LOS. It can be found here [use it through curl -O options]. And it worked! I was able to get the output from my boot.img using the script by running this command : python unpack_bootimg.py --boot_img boot.img

The script’s output in normal format.

But then, i was recommended to add the option --format mkbootimg along with the above command to get the outputed text in terms of mkbootimg arguments, as it would output the values that were expected for the deviceinfo file.

Unfortunately for me though, adding that option to the command gave me an error : error: unrecognized arguments: --format mkbootimg

I then thought and checked the latest LOS branch from where i had got that previous script. And i did find an updated script from LOS21 that did have those options that i needed for mkbootimg format. The new script can be found here

After this, i ran the command again, now with the additional parameters to it and was indeed able to generate the output in mkbootimg format without any errors! The updated command : python unpack_bootimg.py --boot_img boot.img --format mkbootimg

The script’s output in mkbootimg format.

This has given me alot to work with now. I will be looking forward to progress even further and complete the deviceinfo file.

Boot Image Extraction Guide

Wed, 24 Apr 2024 21:53:31 +0530

Guide on how to extract a boot image from any Android phone [Requires Magisk and Computer]

Getting started!

Accessing and modifying system files on your device typically requires superuser permissions. To extract the boot image, we’ll need a root environment. We’ll achieve this by using Magisk.

Manual Process

First, make sure you install TWRP and then flash Magisk through it.
Setup Magisk in your phone.
Connect your phone to your Computer and type adb shell [Ensure that you have adb setup properly].
Now, become root by typing su in the shell on your PC.
Copy/Paste the following code in the shell.

for PARTITION in "boot" "boot_a" "boot_b"; do
  BLOCK=$(find /dev/block \( -type b -o -type c -o -type l \) -iname "$PARTITION" -print -quit 2>/dev/null)
  if [ -n "$BLOCK" ]; then
    echo "$PARTITION" = $(readlink -f "$BLOCK")
  fi
done

This command will display the boot partition paths for both A/B and A-only devices.

Note!

On A/B devices, the loop command will display the boot partition paths for both slots, something like this!

boot_a = /dev/block/sda40
boot_b = /dev/block/sda41

In this case, you can extract the image corresponding to your currently active slot.To determine the active slot, enter the command getprop ro.boot.slot_suffix. If the output is _a, use the path for boot_a; otherwise, use the path for boot_b.

Finally, use the following command to extract the image from the specified boot path:

dd if=<boot_partition_path> of=<output_path>

For example:

dd if=/dev/block/mmcblk0p42 of=/sdcard/boot_a.img

I hope this did work for you, as it did indeed work for me!

CREDITS : Here

Donate

Mon, 01 Jan 0001 00:00:00 +0000

If you do like my work, you can donate me here:

Paypal: Link
UPI: obsidianmaximus@upi

QR code for UPI:
Monero: 46Es9cwspxoY9hhYMy2mdGLwxpYouLWANaBVWiUhhjE37Mr1bB65cU4C9cLkCiaw3hWVaZij7xZs4DrPVUFxTPy5CCkVvsr

Monero QR: