Kristoffer Qvists blogg om allt möjligt

Etikett: Linux

Kryptera loggfiler i Linux med GnuPG och logrotate

I mitt tidigare inlägg skrev jag angående GDPR och kryptering. För den som är intresserad, skriver jag nedan om att kryptera loggfiler i Linux-miljö. Inlägget är inspirerat av det som skrevs i ctrl.blog, eftersom skribenten inte gick djupare i det ämnet. Förhoppningsvis kan mitt inlägg ge lite bättre svar i ämnet.

1. Skapa ett nyckelpar, i en separat maskin

GnuPG är ett fritt program som implementerar OpenPGP-standarden enligt RFC4880 (även känt som PGP). För att öka säkerheten bör ett nyckelpar skapas i en separat maskin. Det minskar eventuella skador, om någon obehörig skulle ta över måldatorn som skall kryptera loggfilerna.

Nyckelpar kan skapas i Linux-, Windows- och Mac-datorer i olika program. Github har skrivit ett inlägg om hur man skapar ett nyckelpar med GPG.

2. Importera enbart den publika nyckeln

För att kryptera loggfilerna i servern måste gpg2 vara installerad i servern. Därefter måste den publika nyckeln importeras till loggservern. Nyckeln används för att kryptera filerna, och kan inte användas för att avkryptera dem. När nyckeln hos på den berörda användaren som exekverar logrotate, skall även nyckeln importeras med kommandot nedan (förutsatt att den publika nyckeln heter public.key):

gpg --import public.key

Det viktiga är också att nyckeln är betrodd. För att få nyckelidentiteter som man har på Linux-servern kör man nedan kommando.

gpg --list-keys --keyid-format LONG

Nyckeln som man importerat kan man också modifiera, om den inte känns igen som betrodd. Kör då nedan kommando (obs! Du bör vara helt säker på att detta är din importerade nyckel):

gpg --edit-key keyid

Därefter väljs förtroende för denna nyckel, som är viktig för att kunna kryptera loggfilerna framöver.

3. Modifiera konfigurationsfilen för att kryptera loggfiler

Lägg till nedan kod för de program som du önskar krypteras. Keyid är det användar-id som är lagrat med nyckeln (exempelvis namn@e-post.com). ”Shred” tar bort loggen i klartext efter att den krypteras och komprimeras. Loggen finns i maskinen enbart 24 timmar i klartext innan den komprimeras och krypteras:

daily
shred
compress
compresscmd /usr/bin/gpg2
compressoptions -r keyid --encrypt --default-key keyid --trust-model always
compressext .gpg

Observera! Ovan kod antar att nyckeln hela tiden är betrodd. Det betyder att ingen kontroll genomförs av nyckelns identitet.

Raspberry Pi som medie-pc

Raspberry Pi är en billig – och hypad – produkt för oss tekniknördar, som gillar att göra de mest intressanta projekt med dem. Ett av många användningsområden är att göra sin gamla tv till en smart-tv. Detta kan ske genom att ansluta enkortsdatorn till tv:n med hjälp av en HDMI till AV/RCA. Vips, så har man en medie-pc!

För några månader sedan (i februari) kom även en uppdaterad version av deras modell B, vilket jag hade tyckt hade varit roligt att leka med. Dock har jag redan några äldre modeller som jag aktivt använder. Det resulterar i att det blir något svårt för att argumentera för att skaffa mig en ytterligare, om än något vassare variant.

Jag har förvisso inte använt mig av den första generationens B-modeller för att användas som medie-pc. Däremot har jag använt min andra generations Raspberry Pi B. Den fungerar rätt bra, även om det ibland kan bli lite struligt när man strömmar film till den från nätverket. Jag har både använt mig av OSMC (tidigare raspbmc) och OpenELEC som operativsystem för detta ändamål. För närvarande använder jag mig av OSMC som operativsystem, och känner mig nöjd med mitt val.

Båda operativsystemen använder sig utav Kodi som skal, vilket gör att båda kan visuellt upplevas som likadant. Öppnar man dock lite under huven märker man att OSMC är lite tyngre och lite mer modifierbar än OpenELEC. Detta då båda har olika designprinciper; det förstnämnda vill att slutanvändaren ska kunna göra så mycket som möjligt med sin installation från början, medan det sistnämnda fokuserar mer på att lämna ett så lätt fotavtryck som möjligt.

En sak som jag upplever skiljde båda åt var vissa inställningar; bland annat kunde OpenELEC ställas in att ta automatiska uppdateringar, vilket OSMC inte kan.

Vilket är bäst?

Egentligen beror det på vilket behov man har, och vad man är mest bekväm med. I och med att jag har använt mig mer av Kodi, så passar det mig bra. Vill man automatisera systemet till att ta emot uppdateringar, och vara ”lätt”, så är OpenELEC valet.

Skapa användare med Perl

Uppdaterat: 2014.09.29

För ett tag sedan var jag tvungen att använda mig utav Perl för att generera användare och sedan ge dem ett tillfälligt lösenord som de kommer att få byta när de har loggat i. Systemet där skriptet användes är ett Linux-system (CentOS 6.5).

Skriptet matchar följande krav:

  • Ha stöd för utf-8
  • Läsa in för- och efternamn från en textfil
  • Skapa unika användare från textfilen
  • Skriva ut användarinformation till en ny textfil per användare, i en särskild mapp

För att kunna köra skriptet krävs modulen Text::Iconv, vilket kan testas genom att skriva perl -e 'use Text::Iconv;' i kommandotolken. Om du inte får ett svar, är modulen installerad. Om du får många felmeddelanden som svar, är modulen inte installerad. Hur man installerar moduler kan jag skriva om i ett annat inlägg, annars kan ni använda det ”gamla” sättet (vad gäller mitt skript) där icke-ASCII-tecken blir bytta till ett x. Eventuellt kan du kika på denna hemsida som förklarar hur man installerar ett verktyg som kan vara till stor hjälp i en CentOS-maskin, på engelska. Vidare står här hur man sedan använder verktyget för att installera modulerna.

Om du undrar över något, går det att skicka in ett mail till mig, så ska jag försöka svara så fort jag kan. Eventuellt, om det är flera som frågar, kan jag publicera svaren här i detta inlägg eller någon annanstans på hemsidan. Dock kommer skriptet inte att kontrollera om användaren lägger till mer input än vad som behövs.

För att få denna kod att vara såpass internationell som möjligt, används engelska kommentarer och variabelnamn.

#!/bin/usr/perl
#############METADATA############
# Author:	Kristoffer Qvist
# Version:	2
# Last
# Modified:	Sep 29th, 2014
# History:	Made utf-8 to
# 		ASCII converting
#		better.
#################################

use warnings;
use strict;
use Text::Iconv;

binmode STDOUT, 'utf8';

# Get file that contains users
my ($file, $userDir) = @ARGV;

while(not -e $file) {
    print("Please, add a valid file containing your users.\n");
    chomp($file = <STDIN>);
}

while(not -e $userDir) {
    print("Please, add a valid folder to store the user password files\n");
    chomp($userDir = <STDIN>);
}

# A basic check for script injection attempt
if($file =~ /;/ or $userDir =~ /;/) {
    die("Script injection attempt found!\n");
}

# Put all new users in array
open(USERS, "<", $file) or die("The file $file could not be opened: $!");
chomp(my @new_users=<USERS>);
while (<USERS>) {
    push (@new_users, $_);
}
close USERS or die($!);

# Get passwd content
my $passwd_file     = "/etc/passwd";
my $passwd_contents = open(PASSWD, "<", "/etc/passwd") or die("$!");
my @passwd;
while (<PASSWD>) {
    push (@passwd, $_);
}
close PASSWD or die("$!");

# Set all existing users in hash
my %existing_users = ();
for(my $i=0;$i<scalar(@passwd);$i++) {
    my @passwd_entry = split /:/,$passwd[$i];
    $existing_users{$passwd_entry[0]} = $i;
}

# Add users to the system and create a random one-time password
foreach my $new_user(@new_users) {
    my @names = split(/ /, $new_user); 

    my $fn = substr($names[0],0,3);
    my $ln = substr($names[1],0,2);

    my $username = $fn.$ln;

    # Converts non-ascii to x (old; latter converting is better)
    # $username =~ s/[^[:ascii:]+]/x/g; 

    # Encode usernames to ascii (new)
    my $convert_this = Text::Iconv->new("UTF-8", "ASCII//TRANSLIT");
    $username = $convert_this->convert($username);
    $username = lc($username);

    # Check for duplicate users, if found add number 
    my $i = 1;
    while(exists $existing_users{$username}) {
        $username =~ s/[0-9]//g;
        $username = $username.$i++;
    }
    $existing_users{$username} = $i;
    my $password = join'', map +(0..9,'a'..'z','A'..'Z','!?()""')[rand(10+26*2)], 1..8;
    `useradd $username -c "$new_user" &> /dev/null`;
    `echo -e "$password\n$password" | passwd $username &> /dev/null`;
    `chage -d 0 $username`;
    open (USERFILE, ">", "$userDir/$username.txt") or die("The file $userDir/$username.txt could not be opened: $!\n");
    print USERFILE "$new_user\n--------------------\n$username: $password";
    close USERFILE or die("The file $userDir/$username.txt could not be closed: $!\n");
}
print("\nBatch completed!\n");

Bash-skript för att förflytta filer

Själv har jag haft behov av att förflytta filer mellan olika mappar i min dator. Då kan det vara skönt att använda sig utav skript som automatiserar förflyttningen helt och hållet (särskilt om man enbart har CLI). Det är skrivet i vanligt shellspråk (bash) och består av enbart några rader kod.

#!/bin/sh
############ METADATA ############
# Author: Kristoffer Qvist
# Description: Moves file(s) to
# predestined destination.
##################################

destination="/path/to/destination"

for file in "$@"; do
    mv "$file" "$destination/$file"
done

Filerna som skall förflyttas finns är argument som skrivs efter skriptnamnet; alltså skript.sh fil.a fil.b som gör att dessa (det vill säga fil.a och fil.b) förflyttas till vald destination, som har skrivits i variabeln ”destination”. Detta skript gör ingen felsökning, och jag tar inget ansvar för eventuella fel som kan inträffa (nej, inte heller förlust av tangentbord eller guldfiskar).

© 2023 qvi.st

Tema av Anders NorenUpp ↑