space

If you’ve read Filippo Valsorda’s guide to using mosh+tmux in a smart way, you’ve probably also noticed that, with mosh, specifying an ssh keyfile is no longer a relatively simple matter of typing:

ssh -i ~/.ssh/keyfilename [...]

but it’s now this mess:

mosh --ssh="ssh -i ~/.ssh/keyfilename" [...]

and that is rather cumbersome, especially considering there’s a better way anyway to manage ssh keyfiles.

If you’re like me, you might have dozens of private key files stored in your local ~/.ssh/ directory, perhaps one for every organization, provider, and datacenter / location combination.

You might have also noticed that sometimes, even without specifying a keyfile, connections go through anyway, and that’s because your local client is cycling through each locally stored key and using it to authenticate against the server. Except that after a certain number of attempts the server will terminate the connection and return:

Received disconnect from [server-address] port 22:2: Too many authentication failures
Connection to [server] closed by remote host.
Connection to [server] closed.

So if you have fewer keys than the maximum number of attempts the server allows, or if the client happens to try them in the right order, you’re good, but any other time you will get kicked off, and you’ll have to manually specify the keyfile as shown above.

There’s an easy fix however. Simply log into all of your servers and:

# nano /etc/ssh/sshd_config
### Increase the number of max attempts to a number higher than your keyfiles
MaxAuthTries 16
### save and exit with control-x and press y when prompted

Now restart the ssh daemon:

# service ssh restart

Do not exit the current session yet, open a new terminal window, and log in [via ssh or mosh, doesn’t matter] to the server without specifying a keyfile, and it should let you in no questions asked!

If everything worked correctly, you can exit the original session, otherwise keep it open, by all means, and double-check your work, and don’t leave it until you are sure you can open a new connection to the server, or else you will be locked out as soon as you close the original session.

This of course will work best in conjunction with global host settings on your client, which you can do by simply doing – on your client:

# nano ~/.ssh/config
### Add the following lines:
Host *
        Port 42022
        User root
### if, for instance, most of your servers have a custom SSH port [like 42022 in my case] and you log in directly as root
### save and exit

This will apply global settings for all of your ssh connections, and you can specify pattern-specific settings for specific servers as well.

In the end, thanks to these simple tips, you’ll reach ninja-admin status and the holy grail of turning:

mosh --ssh="ssh -i ~/.ssh/keyfilename -p42022" root@server-hostname-or-ip

to

mosh server-hostname-or-ip

Also, if you are into servers and security, check out our first-boot hardening script for Debian/Ubuntu machines, called inception. Among several things, it automatically configures everything that is described in this article on you server with no extra effort.

If you take a rapid look at my presentation about openspace’s aenigma state-of-the-art XMPP server automation project, you’ll find out why I encourage everyone to get the fuck out of Telegram right away.

Here is a fun and fast way to set up an autoreply message that gets returned to anyone who contacts you on Telegram on a normal, non-E2EE, direct chat [at least those are still remotely acceptable].

This is based upon this cool article and tested to be working on Ubuntu 18.

sudo apt install python3-pip
pip3 install telethon

nano telegram_autoreply.py

And paste the following content inside:

import time

from telethon import TelegramClient, events

# sample API_ID from https://github.com/telegramdesktop/tdesktop/blob/f98fdeab3fb2ba6f55daf8481595f879729d1b84/Telegram/SourceFiles/config.h#L220
# or use your own
api_id = 000000
api_hash = '2435afd0987efa001824712490cde800'

# fill in your own details here
phone = '+15555555555'
username = 'username'
password = 'two_step_password'  # if you have two-step verification enabled

# content of the automatic reply
message = "Autoreply: \n\n[EN] I'm no longer reachable via non-E2EE channels and especially on centralized services like this one. \n\nTo get in touch with me either start a secret chat here if it's urgent or wake up and move on with your life onto a libre communication protocol. You can find me on XMPP from any modern client that supports OMEMO at <your_JID> or even better on Riot.IM [you can use 'https://mt.os.vu' as custom homeserver to register using openspace's instance] at <your_Riot_ID> and get the fuck out of here once and for all. \n\n[IT] Non sono più raggiungibile attraverso canali non E2EE e specialmente su servizi centralizzati come questo. \n\nPer raggiungermi avvia una chat segreta qui se è urgente o svegliati e vai avanti con la tua vita verso protocolli di comunicazione libre. Trovami su XMPP con un qualsiasi client moderno che supporti OMEMO a <your_JID> o ancora meglio su Riot.IM [puoi registrarti usando il homeserver 'https://mt.os.vu' per usare l'istanza di openspace] a <your_Riot_ID> e scappa da qui fintanto che sei ancora in tempo."

if __name__ == '__main__':
    # Create the client and connect
    # use sequential_updates=True to respond to messages one at a time
    client = TelegramClient(username, api_id, api_hash, sequential_updates=True)


    @client.on(events.NewMessage(incoming=True))
    async def handle_new_message(event):
        if event.is_private:  # only auto-reply to private chats
            from_ = await event.client.get_entity(event.from_id)  # this lookup will be cached by telethon
            if not from_.bot:  # don't auto-reply to bots
                print(time.asctime(), '-', event.message)  # optionally log time and message
                time.sleep(1)  # pause for 1 second to rate-limit automatic replies
                await event.respond(message)


    print(time.asctime(), '-', 'Auto-replying...')
    client.start(phone, password)
    client.run_until_disconnected()
    print(time.asctime(), '-', 'Stopped!')

Now simply:

crontab -e

And paste the following content:

@reboot sleep 16 && python3 telegram_autoreply.py

You can run it manually the first time – before the first reboot – by running:

python3 telegram_autoreply.py

And have someone else write you to see if it works [messages to yourself via saved messages don’t count]. This will obviously work only in direct chats [user to user] and only on non-E2EE chats.

Press ^c to stop the manual run. After reboot run:

ps aux | grep telegram_autoreply

And you should get something along the lines of:

nz@mb:~$ ps aux | grep telegram_autoreply
nz         787  0.0  0.0   4628   828 ?        Ss   14:20   0:00 /bin/sh -c sleep 16 && python3 telegram_autoreply.py
nz        1691  0.0  1.5  97172 32324 ?        S    14:20   0:00 python3 telegram_autoreply.py
nz        4331  0.0  0.0  14428  1036 pts/0    S+   14:46   0:00 grep --color=auto telegram_autoreply

Now it’s time to get started on XMPP and/or even better Riot.IM once and for all!

I’ve recently seen a video where Elon Musk was asked what it means to him that even the very apollo astronauts who landed on the moon think that private space exploration will never be able to perform the missions and make the discoveries that – until today – have been carried out by government space agencies.

He seemed rather emotional and hit hard deep down about the whole thing, and that reminded me of how even those like him who have had success in making the world realize that they are among the few that are actually changing things, no one is really sharing their beliefs and their visions, they’re all just sitting back and waiting for results, passively spending their days watching as the few spend sleepless nights thinking about how to make their ideas appealing to the others, hoping that, thanks to their support, they’ll one day be able to actually bring them to light.

I completely feel his condition, alone in trying to make things happen, while everyone else is only good in believing in things when someone is inspiring them to do so.

It’s an endless, lonely world out there.

If this is actually the day that the enforcement of net neutrality will be obliterated from existence, then this is exactly the day i’ve been waiting for for a long time.

And of course it’s because i don’t think that rules are the solution to things, and of course it’s because i know that extreme competition brings the best to life, and of course it’s because i believe in absolute freedom for everyone.

But it goes so much deeper than that.

It’s because it’s one additional factor that will force people to face the fact that the internet was never meant to be the centralized, hierarchical, administered environment we know today, but it is and eventually will go back to being the very distributed, everpresent, and anonymous stash of layer-1 medium that interconnects every atom of space of our visible universe.

Projects like openNET.io and LibreFibre and so many others will lead the way to decentralize every level of the internet, from the link-layer to each byte of information that flows upon it, and so on forever up to the stars.

Everything will flow in an infinite, redundant mesh comprised of every living device linked together with all of the others, and any and all potential interventions upon that very free flow of life and exploration will be dead long before it is even conceived.

Apparently there are other people that think of this like me strangely enough.

Freedom is inevitable.

https://github.com/openspace42/inception

This script automates what I’ve been doing on every new debian/ubuntu server machine since the dawn of time. It automates every step I can think of to setup and harden a newly created machine. Let me know what you think of it and please contribute on github. Thanks!

Have you ever stopped for an instant to think about the Internet itself, its true nature, what it is, and what it will become?

The amazingly pristine, elegant, and fundamental fact here is that it’s the pure and simple connection layer between the devices that are part of it. The devices that make this network exist *are* the Internet. The way it was conceived implies by its very nature the fact that every device has a direct interface with every other device, with no central nodes or relays. At a connectivity level every device must be able to speak to any other. At a logistics level, every device must host the data it owns, and share it directly with those who want to read it, and it should do the same the other way around when it is interested in another device’s data.

It’s really interesting how surprised everyone is when they discover that the “online world” is actually the real world and that – yeah, hello, fucktards – everything is out there and you should approach it with the same state of mind you walk down a road in a city and experience the outside world.

It’s even more interesting when everyone starts figuring out the implications of these obvious basic concepts, such as the fact that anyone can luckily say whatever the fuck they are thinking. And somehow it is only when these phenomena have tangible and down to earth implications that they become clear to people. Like the fact that a bunch of shit is out there and everyone just passively consumes it and spreads it along.

And as always, for them, the problem is the end result and not the root cause, so we have to:

1. Find issues that don’t exist and rage about them
2. Intervene, of course, because the universe needs our superior intelligence
3. Think of everything backwards, starting from real world complex effects of simple phenomena and analyze everything but the facts introducing opinions based on other fragile and limited ideas that we’ve acquired from someone else
4. Patch the consequences and not look at the issue straight-on
5. Live happily ever after

Ok so basically this is how it works:

1. Someone spits out something completely false and absurd either intentionally or without even knowing [what’s worse? I wouldn’t know…] like they’ve always done, online or offline, since the dawn of time, but hey, now it’s starting to be an issue!
2. People follow along and agree without critically thinking about the world around them and common sense [citation needed]
3. They share the outraging intel they have just acquired from status-quo-defying news sources like “THE ILLUMINATI TRUTH SEEKERS” and such
4. Everyone else out there becomes a slave to this piece of shit news because it’s simply beyond them to think straight about stuff and question their own fucking mental constructs.

You could be mistakenly thinking that the issue at hand here is that people are ignorant and stupid, but you would be wrong. You see, the problem is people saying false stuff in the first place, because that creates problems in a society where it’s cool that no one has a personal fucking opinion about things and has the ability to distinguish between fact and fiction. So let’s go ahead and filter out all of that junk, let’s create a nice little reality distorsion field where everything you get spoon fed is universally true, and live peacefully knowing that everyone’s critical minded approach has been outsourced to some enslaved corporate worker in India.

Kinda like VR is gonna solve the problems with the physical actual fucking world, right?