Szyfrowanie symetryczne AES256 dowolnego tekstu

[mecenas]

Potrzebuję narzędzia offline podobnego do tego: https://encode-decode.com/aes256-encrypt-online/
Chodzi mi o możliwość symetrycznego szyfrowania/deszyfrowania dowolnego tekstu (nie plików) algorytmem AES256.
Najwygodniej, jak byłby to jakiś gotowy pakiet z GUI pod linuxem.
Ale jeśli nie ma takiego, to cokolwiek, co jest opensource i działa off_line.

[akos]

@mecenas

https://www.aescrypt.com/download/

[mecenas]

Próbowałem AEScrypt, instaluje się, ale nie udało mi się tego uruchomić... zgłasza jakiś problem z jednolitą nazwą, nie pamiętam dokładnie. Nie dodaje się też do menu kontekstowego. Chyba dawno nieaktualizowany program (ja operuję na LinuxMint 19.3).
- Ale dzięki za link.

[WitoldC]

@mecenas może standardowe openssl https://www.madboa.com/geek/openssl/#en ... decryption

Dodano po 2 godzinach 26 minutach 49 sekundach:
Tak z ciekawości wie ktoś dlaczego takie coś

Kod: Zaznacz cały

echo "text" | openssl enc -aes-256-cbc -a -k password -nosalt

zwraca inny wynik niż tutaj https://encode-decode.com/aes256-encrypt-online/

Dodano po 2 godzinach 32 minutach 46 sekundach:
@fusywszklanejkuli masz jakiś pomysł co by trzeba było zrobić (przetestowałem -md z wszystkimi dostępnymi "Message Digest"'ami)?

[akos]

@WitoldC

Nie mam pod ręką konsoli żeby to zweryfikować, ale użyłeś trybu cbc w openssl a link do narzędzia online, który podałeś nie prowadzi do https://encode-decode.com/aes-256-cbc-encrypt-online/ tylko do https://encode-decode.com/aes256-encrypt-online/ czyli do trybu domyślnego, prawdopodobnie ecb. Sprawdź co generuje https://encode-decode.com/aes-256-cbc-encrypt-online/
Więcej o trybach: https://stackoverflow.com/questions/122 ... tr-ocb-cfb

@mecenas

Jeśli gui nie jest dla Ciebie najistotniejsze, to możesz sprawdzić jeszcze wersję pythonową albo openssl jak radzi WitoldC.

[mecenas]

Dzięki @WitoldC @akos - zerknę na temat... myślałem o konsoli i openssl, ale wierzyłem, że istnieje jakiś prosty pakiet gui, który ogarnia ten dylemat. Jak widać nie za bardzo jest w czym wybierać a przecież szyfrowanie symetryczne to nie jest jakiś super hiper wynalazek...

[WitoldC]

@akos Obydwa linki generują to samo.
@fusywszklanejkuli wspomniał że powinno być echo z parametrem -n żeby nie generowało na końcu \n (newline).
Najbardziej mnie zdziwiło że w linuksie stworzyłem nowy dokument tekstowy, otwarłem, wpisałem text, zapisałem i plik miał 5 bajtów na końcu \n

[akos]

@WitoldC
Faktycznie, domyślnie jest tam cbc. Fusy napisał, że różnica może wynikać z innej wartości wektora inicjującego, np.

Kod: Zaznacz cały

echo "text" -n | openssl enc -aes-256-cbc -a -k password -nosalt -iv "0"

zwróci:

Kod: Zaznacz cały

AzxHLnzRMd7rIi6Qw5KKDg==

a

Kod: Zaznacz cały

echo "text" -n | openssl enc -aes-256-cbc -a -k password -nosalt -iv "f"

Kod: Zaznacz cały

0coZjANz6EBeuoEqRqNDrw==

Niestety ta stronka nie ma dokumentacji ani źródeł na githubie, więc trudno powiedzieć co tam pod spodem siedzi.

[fusywszklanejkuli]

Zagadnienie mnie na tyle zaciekawiło, że jak zwykle nie mogłem się oprzeć i musiałem zgłębić temat. Udało mi się ostatecznie napisać program, który zwraca takie same wyniki jak openssl.

Na różnice w działaniu konkretnych implementacji mają wpływ wstępna obróbka danych jeszcze przed samym szyfrowaniem (rozmaite sposoby (*) otrzymywania klucza szyfrującego oraz wektora inicjującego), a nawet format wyniku (np. w przypadku interesujących mnie wywołań openssl to "Salted__" + ośmiobajtowa sól + zaszyfrowane dane). Dlatego na rozgryzienie https://encode-decode.com/aes256-encrypt-online/ już nie miałem ochoty.

(*) W tym lepsze i gorsze, np. domyślny sposób używany przez openssl jest niepolecany, co jest wyraźnie sygnalizowane komunikatem *** WARNING : deprecated key derivation used. Using -iter or -pbkdf2 would be better.

PS Przez white-space: normal w linii 554 pliku styles/Subway/theme/content.css znacznik code nie honoruje końców linii, dlatego użyłem pre.

Polecenia, wyniki i program:

Spoiler:

Polecenia i wyniki

$ echo -n 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua._____' | openssl enc -aes-256-cbc -md sha256 -nopad -k 'exercitation ullamco laboris' -S 5555555555555555 -a -p
*** WARNING : deprecated key derivation used.
Using -iter or -pbkdf2 would be better.
salt=5555555555555555
key=67A8FDD6D836BBF5C95D135381D2871364979CEADA015651D33D9AB74CA201C8
iv =2C9EEFFDD0B5CB0A8A7316CED8F17651
U2FsdGVkX19VVVVVVVVVVdSkNHWdQVVES5Y/kzLfjBpvfDgonw04zYC9YWM/0HAd
V/Y/WuPBmdK0a2w3ffOit2mdwByU+42dv+RIItqzSohDBvqyL615XVjXduXO65qQ
Wy+Wg7ABPeylVAJPfOU001NoKVZYMtVz0uMXkvfFZkwn8sgZA3Zbf8f1wmGGShB3

$ echo -n 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua._____' | openssl enc -aes-256-cbc -md sha256 -nopad -k 'exercitation ullamco laboris' -S 5555555555555555 -a -p -iter 1000
salt=5555555555555555
key=7552B6DB4953D3C7B7BB6750A8BC2F84A0AA7A1E7FECF67F6C936A04A4A934BC
iv =237E9933594E9ACB05BAA76EFDD73F63
U2FsdGVkX19VVVVVVVVVVZ4ANSMYver2HCtKYCf5nELxm+upAX3fLhrW0QW9Mehq
d7SlOOljKaVcE2bPRarvvhvLCWDtb2o9iAzZZhx/ovWKGqY5KmKdF3OhEhqvW0ne
H5kZpYO/kljodlDlh3s3RLMY2DrZ4d6UZrLYUph8SGwFMXJvpG4yevyH1qHuO2l1

Program (można uruchomić w repl.it)

package main

import (
    "bytes"
    "crypto/aes"
    "crypto/cipher"
    "crypto/sha256"
    "encoding/base64"
    "encoding/hex"
    "fmt"

    "golang.org/x/crypto/pbkdf2"
)

var aes256KeySize = 256 / 8
var saltSize = 8
var opensslSalted__ = []byte("Salted__")

func keyivDefault(password, salt []byte, iter int) ([]byte, []byte) {
    if len(salt) != saltSize {
        panic("invalid salt size")
    }

    dk := []byte("")
    hash := []byte("")
    for len(dk) < aes256KeySize+aes.BlockSize {
        h := sha256.New()
        h.Write(hash)
        h.Write(password)
        h.Write(salt)
        hash = h.Sum(nil)
        dk = append(dk, hash...)
    }
    key := dk[:aes256KeySize]
    iv := dk[aes256KeySize : aes256KeySize+aes.BlockSize]

    fmt.Printf("salt=%X\n", salt)
    fmt.Printf("key=%X\n", key)
    fmt.Printf("iv =%X\n", iv)

    return key, iv
}

func keyivPBKDF2(password, salt []byte, iter int) ([]byte, []byte) {
    if len(salt) != saltSize {
        panic("invalid salt size")
    }

    dk := pbkdf2.Key(password, salt, iter, aes256KeySize+aes.BlockSize, sha256.New)
    key := dk[:aes256KeySize]
    iv := dk[aes256KeySize:]

    fmt.Printf("salt=%X\n", salt)
    fmt.Printf("key=%X\n", key)
    fmt.Printf("iv =%X\n", iv)

    return key, iv
}

func encrypt(plaintext, password, salt []byte, kdf func(password, salt []byte, iter int) ([]byte, []byte), iter int) []byte {
    fmt.Println("\nencrypting...")

    if len(plaintext)%aes.BlockSize != 0 {
        panic("plaintext size is not a multiple of the block size")
    }

    key, iv := kdf(password, salt, iter)

    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err)
    }

    ciphertext := make([]byte, len(opensslSalted__)+saltSize+len(plaintext))
    s := ciphertext
    copy(s, opensslSalted__)
    s = s[len(opensslSalted__):]
    copy(s, salt)
    s = s[saltSize:]
    mode := cipher.NewCBCEncrypter(block, iv)
    mode.CryptBlocks(s, plaintext)

    fmt.Printf("ciphertext=%X\n", ciphertext)
    fmt.Printf("ciphertext_base64=%s\n", base64.StdEncoding.EncodeToString(ciphertext))

    return ciphertext
}

func decrypt(ciphertext, password []byte, kdf func(password, salt []byte, iter int) ([]byte, []byte), iter int) {
    fmt.Println("\ndecrypting...")
    fmt.Printf("ciphertext=%X\n", ciphertext)

    if len(ciphertext) < len(opensslSalted__)+saltSize {
        panic("ciphertext too short")
    }

    s := ciphertext
    if !bytes.Equal(s[:len(opensslSalted__)], opensslSalted__) {
        panic("invalid openssl ciphertext")
    }

    s = s[len(opensslSalted__):]
    salt := s[:saltSize]
    key, iv := kdf(password, salt, iter)

    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err)
    }

    s = s[saltSize:]
    if len(s)%aes.BlockSize != 0 {
        panic("ciphertext size is not a multiple of the block size")
    }
    mode := cipher.NewCBCDecrypter(block, iv)
    plaintext := make([]byte, len(s))
    mode.CryptBlocks(plaintext, s)

    fmt.Printf("plaintext=%s\n", plaintext)
}

func main() {
    password := []byte("exercitation ullamco laboris")
    salt, _ := hex.DecodeString("5555555555555555")
    pbkdf2Iter := 1000

    for _, v := range []struct {
        keyivname     string
        keyiv         func(password, salt []byte, iter int) ([]byte, []byte)
        ciphertextb64 string
    }{
        {"default", keyivDefault, `U2FsdGVkX19VVVVVVVVVVdSkNHWdQVVES5Y/kzLfjBpvfDgonw04zYC9YWM/0HAd
V/Y/WuPBmdK0a2w3ffOit2mdwByU+42dv+RIItqzSohDBvqyL615XVjXduXO65qQ
Wy+Wg7ABPeylVAJPfOU001NoKVZYMtVz0uMXkvfFZkwn8sgZA3Zbf8f1wmGGShB3`},
        {"PBKDF2", keyivPBKDF2, `U2FsdGVkX19VVVVVVVVVVZ4ANSMYver2HCtKYCf5nELxm+upAX3fLhrW0QW9Mehq
d7SlOOljKaVcE2bPRarvvhvLCWDtb2o9iAzZZhx/ovWKGqY5KmKdF3OhEhqvW0ne
H5kZpYO/kljodlDlh3s3RLMY2DrZ4d6UZrLYUph8SGwFMXJvpG4yevyH1qHuO2l1`},
    } {
        fmt.Printf("\nusing %s openssl key and iv derivation\n", v.keyivname)
        encrypted := encrypt([]byte("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua._____"), password, salt, v.keyiv, pbkdf2Iter)
        ciphertext, _ := base64.StdEncoding.DecodeString(v.ciphertextb64)
        if !bytes.Equal(encrypted, ciphertext) {
            fmt.Println("...unexpected encryption result!")
        }
        decrypt(ciphertext, password, v.keyiv, pbkdf2Iter)
    }
}

[The Real McCoin]

Potrzebuję narzędzia offline podobnego do tego: https://encode-decode.com/aes256-encrypt-online/

Proszę: https://a3diti.github.io/aes256-offline/

[mecenas]

Proszę: https://a3diti.github.io/aes256-offline/

Dziękuję serdecznie.

Ciekawe, że algorytm AES-256-CBC zwraca tutaj inny wynik niż taki sam (?) AES-256-CBC na stronce:
https://encode-decode.com/aes-256-cbc-encrypt-online/

[The Real McCoin]

algorytm AES-256-CBC zwraca tutaj inny wynik

Szyfrowanie tutaj zwraca inny wynik za każdym razem.
Nawet jeżeli użyjesz tego samego hasła i tekstu jawnego.
To dlatego, że hasło tutaj jest solone (sól dopisywana jest do szyfrogramu), powstaje inny klucz szyfrujący i przez to szyfrogram.

[WitoldC]

Udało mi się wygenerować taki sam wynik w PHP https://repl.it/repls/SpringgreenNextClosedsource

<html>
<head>
<title>PHP Test</title>
</head>
<body>
<?php
$key="password";
$plaintext = "text";

$cipher = "aes-256-cbc";
$ivlen = openssl_cipher_iv_length($cipher);
$iv = openssl_random_pseudo_bytes($ivlen);
$ciphertext = openssl_encrypt($plaintext, $cipher, $key, $options=0);

echo $ciphertext."\r\n";

$original_plaintext = openssl_decrypt($ciphertext, $cipher, $key, $options=0);
echo $original_plaintext."\n";
?>
</body>
</html>

Kod: Zaznacz cały

PHP Warning:  openssl_encrypt(): Using an empty Initialization Vector (iv) is potentially insecure and not recommended

[fusywszklanejkuli]

@WitoldC, ta informacja pozwala już poznać sposób działania interesującej nas strony, najgorszy z możliwych, z powodu braku rozciągania klucza (ach te polskie terminy) i zerowego wektora inicjującego:

$ echo -n text | openssl enc -aes-256-cbc -K $(echo -n password | xxd -ps) -iv 0 -nosalt -a -p
hex string is too short, padding with zero bytes to length
hex string is too short, padding with zero bytes to length
key=70617373776F7264000000000000000000000000000000000000000000000000
iv =00000000000000000000000000000000
upYAR29CYgqPzkp5gclTuA==

Strona https://a3diti.github.io/aes256-offline/ jest lepsza, choć można jej zarzucić używanie kiepskiej metody uzyskiwania klucza i IV oraz przestarzałego MD5:

$ echo "U2FsdGVkX1+21O5RB08bavFTq7Yq/gChmXrO3f00tvJaT55A5pPvqw0zFVnHSW1o" | openssl enc -d -aes-256-cbc -md md5 -k password -a -p
*** WARNING : deprecated key derivation used.
Using -iter or -pbkdf2 would be better.
salt=B6D4EE51074F1B6A
key=F131BF996CF4AC205031D1D02F4F6ACE9E79F1540482F3B9B1198E0D85F7FD0F
iv =1568D012C4856CC549484173CB2DCDCC
Made with Gibberish

[caps89]

Czy zaszyfrowanie w ten sposób klucza prywatnego i jego wydrukowanie a następnie noszenie w portfelu to dobry pomysł?

[Bit-els]

@caps89 tak. Ale prościej skorzystać z gotowych rozwiązań:
https://www.bitaddress.org

Pokręć myszka do 100%
zakładka Paper Wallet,
odhacz Hide art I bip38 encrypt
wpisz hasło
generuj
drukuj

na próbę jak to działa zrób tak na ekranie i zesweepuj klucz prywatny jakimś mobilnym portfelem.
Dostaniesz prośbę o hasło, wpisz, pojawi sie info, że adres jest pusty.
Ale będzie to oznaczało dobrą procedurę

Najlepiej generować takie portfele na kompie odłączonym od netu z pliku ściągniętego z githuba, jest na tej stronie link. I jeśli jeszcze drukarka też jest tylko do takiego offline kompa podłączona, to juz jest naprawdę ok.

[caps89]

Stronę dobrze znam, generowalem na niej klucz prywatny na przedpotopowym laptopie bez zamontowanego dysku z systemem załadowanym do pamięci ram, offline. Klucz prywatny schowany w dobrze zaszyfrowanym pliku, klucz prywatny nigdy nie był "widoczny" w żadnym komputerze online czy z windowsem. Zaszyfrowany plik w kilku kopiach. Ale boje się trzymać btc tylko w formie elektronicznej chciałbym mieć również forme papierowa. I właśnie myślę nad zapisaniem klucza prywatnego w formie zaszyfrowanej i trzymaniu go w kilku miejscach. Do tego zakopanie kodu prywatnego w kilku częściach w różnych odległych od siebie rejonach (lasy łąki itp)

[The Real McCoin]

można jej zarzucić

Widzę, że jesteś koneserem, więc proszę:

AES 128 encryption, with random IV. And PBKDF2 (Hmac SHA1, 1000 iterations) is used for password. Result is signed with HMAC MD5, for verification, and then encoded using Base64

https://www.infoencrypt.com/

[mecenas]

@The Real McCoin @fusywszklanejkuli

A co myślicie o tym:
https://pteo.paranoiaworks.mobi/

Dodano po 14 minutach 11 sekundach:
Jest wersja na komputer: https://paranoiaworks.mobi/download/ , piszą, że: "Jest całkowicie darmowy i niezawodny - open source."
- Skąd mam wiedzieć, że to opensource?

[WitoldC]

Skąd mam wiedzieć, że to opensource?

Na dole masz linki do źródeł "Source Codes"