Andreas Kling oznámil, že jelikož už se nevěnuje nezávislému operačnímu systému SerenityOS, ale výhradně jeho webovému prohlížeči Ladybird, přičemž vyvíjí primárně na Linuxu, SerenityOS opustí a Ladybird bude nově samostatný projekt (nový web, repozitář na GitHubu).
Po dvou měsících vývoje byla vydána nová verze 0.13.0 programovacího jazyka Zig (GitHub, Wikipedie). Přispělo 73 vývojářů. Přehled novinek v poznámkách k vydání.
Na čem aktuálně pracují vývojáři GNOME a KDE? Pravidelný přehled novinek v Týden v GNOME a Týden v KDE.
Před 70 lety, 7. června 1954, ve věku 41 let, zemřel Alan Turing, britský matematik, logik, kryptoanalytik a zakladatel moderní informatiky.
NiceGUI umožňuje používat webový prohlížeč jako frontend pro kód v Pythonu. Zdrojové kódy jsou k dispozici na GitHubu pod licencí MIT.
Open source platforma Home Assistant (Demo, GitHub, Wikipedie) pro monitorování a řízení inteligentní domácnosti byla vydána ve verzi 2024.6. Z novinek lze vypíchnout lepší integraci LLM (OpenAI, Google AI, Ollama) nebo podporu Matter 1.3.
IKEA ve Spojeném království hledá zaměstnance do své nové pobočky. Do pobočky v počítačové hře Roblox. Nástupní mzda je 13,15 liber na hodinu.
Alyssa Rosenzweig se v příspěvku na svém blogu Vulkan 1.3 na M1 za 1 měsíc rozepsala o novém Vulkan 1.3 ovladači Honeykrisp pro Apple M1 splňujícím specifikaci Khronosu. Vychází z ovladače NVK pro GPU od Nvidie. V plánu je dále rozchodit DXVK a vkd3d-proton a tím pádem Direct3D, aby na Apple M1 s Asahi Linuxem běžely hry pro Microsoft Windows.
Byla vydána (𝕏) květnová aktualizace aneb nová verze 1.90 editoru zdrojových kódů Visual Studio Code (Wikipedie). Přehled novinek i s náhledy a animovanými gify v poznámkách k vydání. Ve verzi 1.90 vyjde také VSCodium, tj. komunitní sestavení Visual Studia Code bez telemetrie a licenčních podmínek Microsoftu.
Byla vydána (Mastodon, 𝕏) nová verze 2024.2 linuxové distribuce navržené pro digitální forenzní analýzu a penetrační testování Kali Linux (Wikipedie). Přehled novinek se seznamem nových nástrojů v oficiálním oznámení.
Ako som už spomínal, potreboval som použiť AES. Je to symetrický šifrovací algoritmus pracujúci na blokoch pevnej dĺžky. Pre jeho použitie je potrebné najprv vytvoriť šifrovací kľúč stanovenej dĺžky. Šifrované dáta samozrejme chceme chrániť heslom – ktoré ale má byť ľubovoľne dlhé. Tento rozpor môžeme jednoducho vyriešiť tým, že z užívateľom zadaného hesla spočítame hash a ten sa potom použije ako šifrovací kľúč. Ako možno viete, hashovacia funkcia je funkcia, ktorá pre ľubovoľné vstupné dáta vygeneruje blok dát pevnej dĺžky. Pritom má tú vlastnosť, že je ťažké nájsť iné vstupné dáta, pre ktoré hashovacia funkcia vrátí rovnakú hodnotu a teda aj minimálna zmena vstupných dát znamená zmenu vo výstupe hashovacej funkcie. Ako však zrátať hash? Opäť prichádza na pomoc OpenSSL. Ponúka niekoľko hashovacích algoritmov. Ja som si zvolil SHA1.
#include <openssl/sha.h> … SHA_CTX c; unsigned char sha1[32]; memset(sha1,0,sizeof(sha1)); SHA1_Init(&c); SHA1_Update(&c,password,strlen(password)); SHA1_Final(sha1,&c);
Ako ste si možno všimli, premenná sha1 je pole 32 bajtov, ale SHA1 produkuje 160bitový hash – teda 20 bajtov. 32 potrebujeme kvôli AES, ktoré môže použiť kľúče dĺžky 128, 192 alebo 256 bitov. Ak by sme chceli počítať SHA1 z dlhších dát, môžeme volať funkciu SHA1_Update()
opakovane:
SHA1_Init(&c); while ((length=read(fd,block,sizeof(block)))>0) SHA1_Update(&c,block,(unsigned long)length); SHA1_Final(sha1,&c);
Keď už máme blok dát, ktorý môžeme použiť ako šifrovací kľúč, môžeme ho použiť pre inicializáciu AES algoritmu v OpenSSL:
#include <openssl/aes.h> … AES_KEY encryptionKey; int keyBits=192; AES_set_encrypt_key(sha1,keyBits,&encryptionKey);
Algoritmus AES (podobne ako iné blokové šifrovacie algoritmy) môže pracovať v rôznych módoch. Mód ECB je jednoduchší, pretože výsledok šifrovania bloku dát závisí len od kľúča a vstupného bloku dát. Zložitejší (a bezpečnejší) je CBC, pri ktorom výsledok šifrovania Ntého bloku závisí od výsledku šifrovania bloku predchádzajúceho. Pre situáciu, ktorú som potreboval riešiť ja, však postačoval ECB mód:
unsigned char *inputBlock; unsigned char *outputBlock; int enc=AES_ENCRYPT; // for decryption AES_DECRYPT AES_ecb_encrypt(inputBlock, outputBlock,&encryptionKey,enc);
Ak enc
má hodnotu AES_ENCRYPT
, tento kód zoberie 16 bajtov (128 bitov) plaintextu z inputBlock
a umiestni zašifrovaný blok 16 bajtov na outputBlock
. Ak má enc
hodnotu AES_DECRYPT
, tak inputBlock
ukazuje na zašifrované dáta a dešifrované dáta budú uložené na outputBlock
.
Funkcia pre šifrovanie v CBC móde má trocha viac parametrov:
void AES_cbc_encrypt(const unsigned char *in, unsigned char *out, const unsigned long length, const AES_KEY *key, unsigned char *ivec, const int enc);
length
je počet bajtov na vstupe, ivec
je „inicializačný vektor“, ktorým sa prenáša informácia medzi jednotlivými blokmi.
Problémom pri použití blokovej šifry je zistenie, koľko bajtov vlastne má mať výstup. Na výstupe totiž dostaneme vždy násobok veľkosti AES bloku – 16 bajtov. Riešenie je v použití „zarovnania“ – angl. padding. To sa spravidla implementuje tak, ako to predpisuje PKCS#5. Teda tak, že bajty, ktoré chýbajú v poslednom bloku, sa vyplnia hodnotou určujúcou, koľko bajtov treba odobrať od konca dešifrovaných dát tak, aby sme dostali správnu dĺžku. Ak napríklad potrebujem zašifrovať 25 bajtov dát, tak nájdeme najbližší násobok 16 (veľkosť AES bloku) – to je 32. Bajty od 26 po 32 pred zašifrovaním vyplníme hodnotou 7 (teda 32-25). Po rozšifrovaní potom stačí zobrať posledný bajt a podľa neho vieme, koľko bajtov bolo použitých pre padding. Ak na vstupe už máme násobok veľkosti bloku, umelo doplníme na vstupe jeden blok obsahujúci len padding.
Pri prehrabávaní sa v OpenSSL som narazil na ďalší kus funkcionality, ktorý sa mi hodil. Chcel som výsledok šifrovania zapísať do textovej formy, ktorú možno prenášať ako tlačiteľný text. V praxi sa na tento účel používa kódovanie BASE-64. Po krátkom pátraní som prišiel na to, že existujú prinajmenšom dve kódovania BASE-64. Jedno ponúka libc vo funkciách a64l()
a l64a()
– zodpovedajú POSIX-u, ale všetci používajú MIME-BASE 64, ktoré používa inú sadu znakov. A práve tento druhý variant ponúka OpenSSL.
Okrem hashovacích a šifrovacích funkcií OpenSSL obsahuje aj knižnicu nazvanú BIO – čo je abstrakcia sady vstupných a výstupných funkcií. Ide vlastne o sadu metód, ktoré fungujú ako čierna skrinka. Možno do nich na jednej strane zapisovať a na druhej strane čítať. Jednou takouto metódou je „mem“. Vyrobí ju funkcia BIO_s_mem() a do všeobecného rozhrania ju obalí BIO_new():
#include <openssl/bio.h> #include <openssl/evp.h> … BIO bio=*BIO_new(BIO_s_mem());
Na takto získanú premennú je možné použiť BIO_write()
a BIO_read()
:
int BIO_read(BIO *b, void *buf, int len); int BIO_write(BIO *b, const void *buf, int len);
Metóda „mem“ má tú vlastnosť, že tie isté dáta, ktoré do nej zapíšeme, z nej
aj prečítame. Ďalšou metódou je napr. tá, ktorú vracia funkcia BIO_f_base64()
. Má tú vlastnosť, že to, čo do nej zapíšeme, si táto metóda ukladá v kódovaní MIME-BASE64 a to, čo z nej prečítame, je zasa spätne dekódované. Dve metódy možno zreťaziť použitím funkcie BIO_push()
:
BIO *mem=BIO_new(BIO_s_mem()); BIO *b64=BIO_new(BIO_f_base64()); BIO *bio=BIO_push(b64,mem);
Pri takomto zreťazení dáta zapísané do bio
môžeme prečítať z mem
a dostaneme MIME-BASE64 zakódované dáta. Naopak MIME-BASE64 kódované dáta zapísané do mem
môžeme prečítať z bio
a dostaneme pôvodná dáta. Uvoľnenie dát spojených so štruktúrou BIO robí funkcia BIO_free()
. Pokiaľ boli viaceré BIO
štruktúry zreťazené, uvoľní ich naraz BIO_free_all()
. Chovanie týchto stavebných blokov môžeme ovplyvniť napr. nastavením flagov funkciou BIO_set_flags()
.
Napr. volanie
BIO_set_flags(b64,BIO_FLAGS_BASE64_NO_NL);
zariadi, že text generovaný takouto metódou nebude automaticky ukončený znakom nového riadku. Okrem „mem“ a „base64“ existujú rôzne ďalšie BIO metódy, ktoré napr. vedia zo vstupných dát zrátať SHA1 alebo MD5, nastaviť ako vstup (alebo výstup) súbor či socket, šifrovať ich atď. Napr. nasledujúci kúsok kódu číta MIME-Base64 kódované dáta a tlačí na štandardný výstup pôvodné nekódované dáta:
BIO *fl=BIO_new_file("inputfile.dat","r"); BIO *b64=BIO_new(BIO_f_base64()); BIO *bio=BIO_push(b64,fl); char ch; while (BIO_read(b64,&ch,1)>0) printf("%c",ch); BIO_free_all(bio);
A tento vypíše SHA1 vstupného buffra:
char sha1[20]; memset(sha1,0,sizeof(sha1)); BIO *sha1bio=BIO_new(BIO_f_md()); BIO_set_md(sha1bio,EVP_sha1()); /* to discard the written data after calculating SHA1: */ BIO_push(sha1bio,BIO_new(BIO_s_null())); BIO_write(sha1bio,buffer,bufferLength); /* can be called several times */ BIO_flush(sha1bio); BIO_gets(sha1bio,sha1,sizeof(sha1)); for (i=0;i<sizeof(sha1);i++) printf("%02x",sha1[i]&0xff); printf("\n");
OpenSSL je rozsiahla knižnica a my sme sa len dotkli niektorých tém. Ale dúfam, že vás zaujali.
Šifrovanie s dĺžkou kľúča 192 alebo 256 bitov môže podliehať exportným obmedzeniam.Nástroje: Tisk bez diskuse
Tiskni Sdílej:
pochuťiť.
SHA1_Init(&c); SHA1_Update(&c,password,(unsigned long)strlen(password)); SHA1_Final(sha1,&c);Už ani nemá cenu číst dál, protože v článku je jasně naznačen špatný způsob programování. strlen totiž vrací size_t a né unsigned long a nelze spoléhat na to, že size_t je stejně velký jako unsigned long. Pokud SHA1_Update opravdu chce unsigned long jako argument znamenající velikost bufferu, pak je to špatně navržená funkce.
int SHA1_Update(SHA_CTX *c, const void *data, size_t len);(teda aspoň v sha.h, v nápovede je stále unsigned long)
sha
je pole 32 znaku. ne vsude je znak bajtovy.
#include "gcrypt.h" //...etc.. gcry_md_hd_t digest=0; int num; char buffer[4096]; FILE*instream=fopen("foo","rb"); gcry_md_open(&digest,GCRY_MD_SHA1,0); while ((num = fread(buffer, 1, 4096, instream)) != 0) gcry_md_write (digest, buffer, num); char * result = gcry_md_read (digest,0); for(num=0; gcry_md_get_algo_dlen (GCRY_MD_SHA1) > num ; ++num) printf ("%02x",result[num]); printf ("\n"); gcry_md_close (digest);a nekamenujte me jestli vam to nepude skompilit napoprvy, psal sem to skoro zpameti.