Jak zaszyfrować ciąg znaków w Javie

Polecam użycie jakiegoś standardowego symetrycznego cyfera, który jest powszechnie dostępny jak DES, 3DES lub AES . Chociaż nie jest to najbezpieczniejszy algorytm, istnieje wiele implementacji i wystarczy podać klucz każdemu, kto ma odszyfrować informacje w kodzie kreskowym. javax.krypto.Cipher jest tym, z czym chcesz pracować.

Załóżmy, że bajty do zaszyfrowania są w

byte[] input;

Następnie będziesz potrzebujesz klucza i wektora inicjalizacji bajtów

byte[] keyBytes;
byte[] ivBytes;

Teraz możesz zainicjować szyfr dla wybranego algorytmu:

// wrap key data in Key/IV specs to pass to cipher
SecretKeySpec key = new SecretKeySpec(keyBytes, "DES");
IvParameterSpec ivSpec = new IvParameterSpec(ivBytes);
// create the cipher with the algorithm you choose
// see javadoc for Cipher class for more info, e.g.
Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");

Szyfrowanie przebiegałoby tak:

cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);
byte[] encrypted= new byte[cipher.getOutputSize(input.length)];
int enc_len = cipher.update(input, 0, input.length, encrypted, 0);
enc_len += cipher.doFinal(encrypted, enc_len);

I deszyfrowanie w ten sposób:

cipher.init(Cipher.DECRYPT_MODE, key, ivSpec);
byte[] decrypted = new byte[cipher.getOutputSize(enc_len)];
int dec_len = cipher.update(encrypted, 0, enc_len, decrypted, 0);
dec_len += cipher.doFinal(decrypted, dec_len);

Jest to pierwsza strona, która pojawia się za pośrednictwem Google i bezpieczeństwa luki we wszystkich implementacjach sprawiają, że marudzę, więc jestem publikowanie tego, aby dodać informacje dotyczące szyfrowania dla innych, ponieważ minęło 7 lat od pierwotnego posta. Posiadam tytuł magistra w Inżynierii Komputerowej i spędził dużo czasu studiując i ucząc się Kryptografii, więc rzucam moje dwa grosze, aby internet był bezpieczniejsze miejsce.

Należy również pamiętać, że wiele wdrożeń może być bezpieczne dla danego sytuacji, ale po co z nich korzystać i potencjalnie przypadkowo zrobić błąd? Używaj najsilniejszych dostępnych narzędzi, chyba że masz konkretny powód. Ogólnie polecam korzystanie z biblioteki i trzymaj się z dala od szczegółów, jeśli możesz.

Aktualizacja 4/5/18: przepisałem kilka części, aby były łatwiejsze do zrozumienia i zmieniłem zalecaną bibliotekę z Jasypt na Nowy Google biblioteka Tink , Polecam całkowite usunięcie Jasypt z istniejącej konfiguracji.

Przedmowa

Przedstawię poniżej podstawy bezpiecznej kryptografii symetrycznej i wskażę typowe błędy, które widzę w Internecie, gdy ludzie implementują krypto samodzielnie za pomocą standardowej biblioteki Java. Jeśli chcesz po prostu pominąć wszystkie szczegóły przejechane do Nowa biblioteka Google Tink zaimportuj ją do swojego projektu i użyj trybu AES-GCM dla wszystkich Twoich szyfrów i będziesz bezpieczny.

Teraz jeśli chcesz poznać szczegóły jak szyfrować w Javie Czytaj dalej:)

Szyfry Blokowe

Najpierw musisz wybrać symetryczny szyfr blokowy. Szyfr blokowy to funkcja/program komputerowy służący do tworzenia Pseudolosowości. Pseudo-losowość jest fałszywą losowością, że żaden komputer inny niż komputer kwantowy nie byłby w stanie odróżnić jej od rzeczywistej losowości. Blok Szyfr jest jak fundament kryptografii, a gdy jest używany z różnymi trybami lub schematami, możemy tworzyć szyfry.

Jeśli chodzi o algorytmy szyfru blokowego dostępne dzisiaj, upewnij się, że nigdy , powtarzam nigdy nie używaj DES , powiedziałbym nawet, że nigdy nie używaj 3DES . Jedynym szyfrem blokowym, który nawet w wydaniu NSA Snowdena był w stanie zweryfikować, że jest naprawdę tak blisko pseudolosowego, jak to tylko możliwe, jest AES 256. Istnieje również AES 128, różnica polega na tym, że AES 256 pracuje w 256-bitowych blokach, a AES 128 pracuje w 128 blokach. W sumie AES 128 jest uważany za Bezpieczny, chociaż odkryto pewne słabości, ale 256 jest tak solidny, jak to tylko możliwe.

CiekawostkaDES została złamana przez NSA, kiedy została założona i faktycznie trzymała w tajemnicy przez kilka lat i chociaż niektórzy ludzie nadal twierdzą, że 3DESjest Bezpieczna, istnieje sporo prac naukowych, które znalazły i przeanalizowały słabości NSA. 3DES.

Tryby Szyfrowania

Szyfrowanie jest tworzone, gdy bierzesz szyfr blokowy i używasz określonego schematu, tak aby losowość była połączona z kluczem, aby stworzyć coś, co jest odwracalne, o ile znasz klucz. Jest to określane jako tryb szyfrowania.

Oto przykład trybu szyfrowania i najprostszego trybu znanego jako EBC, abyś mógł wizualnie zrozumieć, co się dzieje:

The tryby szyfrowania, które można zobaczyć najczęściej w Internecie, to:

EBC CTR, CBC, GCM

Istnieją inne tryby poza wymienionymi, a naukowcy zawsze pracują nad nowymi trybami, aby poprawić istniejące problemy.

Przejdźmy teraz do implementacji i tego, co jest bezpieczne. nigdy używaj ECB jest to złe w ukrywaniu powtarzających się danych, jak pokazało słynne Linux penguin.

Podczas implementacji w Javie, Uwaga jeśli użyjesz poniższego kodu, tryb ECB jest domyślnie ustawiony:

Cipher cipher = Cipher.getInstance("AES");

... NIEBEZPIECZEŃSTWO TO JEST PODATNOŚĆ! i niestety, jest to widoczne w całym StackOverflow i online w samouczkach i przykładach.

Nonces i IVs

W odpowiedzi na problem wykryty w trybie EBC powstały nounki znane również jako IVs. Chodzi o to, że generujemy nową zmienną losową i dołączamy ją do każdego szyfrowania, aby po zaszyfrowaniu dwóch wiadomości, które są takie same wyglądają inaczej. Piękno za tym polega na tym, że kroplówka lub nonce to wiedza publiczna. Oznacza to, że atakujący może mieć do tego Dostęp, ale dopóki nie ma Twojego klucza, nie może nic zrobić z tą wiedzą.

Typowe problemy, które zobaczę, to to, że ludzie będą ustawiać IV jako wartość statyczną, jak w tej samej stałej wartości w kodzie. a oto pułapka na kroplówki w momencie, gdy powtarzasz jedną, narażasz całe bezpieczeństwo swojego szyfrowanie.

Generowanie losowego IV

SecureRandom randomSecureRandom = SecureRandom.getInstance("SHA1PRNG");
byte[] iv = new byte[cipher.getBlockSize()];
randomSecureRandom.nextBytes(iv);
IvParameterSpec ivParams = new IvParameterSpec(iv);

Uwaga: SHA1 jest zepsuty, ale nie mogłem znaleźć, jak poprawnie zaimplementować SHA256 w tym przypadku użycia, więc jeśli ktoś chce się temu przyjrzeć i zaktualizować, byłoby super! Również ataki SHA1 nadal są niekonwencjonalne, ponieważ pęknięcie ogromnego klastra może potrwać kilka lat. Sprawdź szczegóły tutaj.

Implementacja CTR

Nie jest wymagana wyściółka dla CTR mode.

 Cipher cipher = Cipher.getInstance("AES/NoPadding");

Implementacja CBC

Jeśli zdecydujesz się zaimplementować tryb CBC zrób to z PKCS7Padding w następujący sposób:

 Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");

Podatność na CBC i Ctr oraz dlaczego warto stosować GCM

Chociaż niektóre inne tryby, takie jak CBC i CTR są bezpieczne, napotykają problem, w którym atakujący może odwrócić zaszyfrowane dane, zmieniając ich wartość po odszyfrowaniu. Załóżmy, że zaszyfrujesz wyimaginowaną wiadomość bankową "sprzedaj 100", twoja zaszyfrowana wiadomość wygląda tak "eu23ng" atakujący zmienia jeden bit na "eu53ng" i nagle po odszyfrowaniu wiadomości odczytuje się jako "sprzedaj 900".

Aby tego uniknąć, większość Internetu używa GCM, a za każdym razem, gdy widzisz HTTPS, prawdopodobnie używają GCM. GCM podpisuje zaszyfrowaną wiadomość za pomocą skrótu i sprawdza, czy wiadomość nie została zmieniona przy użyciu tego podpisu.

Unikałbym wdrażania GCM ze względu na jego złożoność. Lepiej używać Googles Nowa biblioteka Dzwoneczek ponieważ tutaj znowu, jeśli przypadkowo powtórzysz kroplówkę, narażasz klucz w walizce z GCM, co jest ostateczną wadą bezpieczeństwa. Nowi badacze pracują nad trybami szyfrowania IV odpornymi na powtarzanie, w których nawet jeśli powtórzysz IV, klucz nie jest zagrożony, ale to jeszcze nie ma głównego nurtu.

Teraz, jeśli chcesz zaimplementować GCM, oto link do ładnej implementacji GCM. Jednak nie mogę zapewnić bezpieczeństwa lub jeśli jest prawidłowo wdrożony ale to obniża podstawę. Zauważ również, że w przypadku GCM nie ma wyściółki.

Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");

Klucze a hasła

Kolejną bardzo ważną uwagą jest to, że jeśli chodzi o kryptografię klucz i hasło to nie to samo. Klucz w kryptografii musi mieć pewną entropię i losowość, aby można go było uznać za Bezpieczny. Dlatego musisz upewnić się, że używasz odpowiednich bibliotek kryptograficznych, aby wygenerować klucz dla Ciebie.

Więc naprawdę masz dwa pierwszą z nich jest użycie kodu znalezionego na w wątku Stoskoverflow do generowania losowych kluczy. To rozwiązanie wykorzystuje Bezpieczny generator liczb losowych, aby utworzyć klucz od podstaw, który można wykorzystać.

Inną mniej bezpieczną opcją jest użycie danych wejściowych użytkownika, takich jak hasło. Problem, o którym rozmawialiśmy, polega na tym, że hasło nie ma wystarczającej entropii, więc musielibyśmy użyć PBKDF2, algorytmu, który pobiera hasło i wzmacnia to. Oto implementacja Stoskoverflow spodobała mi się. Jednak Biblioteka Dzwoneczek Google ma to wszystko wbudowane i powinieneś z tego skorzystać.

Programiści Androida

Jednym z ważnych punktów, na które należy zwrócić uwagę, jest to, że Twój kod Androida jest odwracalny i w większości przypadków większość kodu java jest zbyt. Oznacza to, że hasło jest zapisane w postaci zwykłego tekstu w kodzie. Haker może go łatwo odzyskać. Zazwyczaj w przypadku tego typu szyfrowania należy użyć Kryptografia asymetryczna i tak dalej. Jest to poza zakresem tego postu, więc uniknę nurkowania w nim.

An interesujące Czytanie z 2013 : wskazuje, że 88% implementacji kryptograficznych w Androidzie zostało wykonanych nieprawidłowo.

Myśli Końcowe

Po raz kolejny sugerowałbym uniknięcie implementacji biblioteki java dla krypto bezpośrednio i użycie Google Tink , zaoszczędzi ci to bólu głowy, ponieważ naprawdę wykonali dobrą robotę implementując wszystkie / align = "left" / A nawet wtedy upewnij się, że sprawdzasz problemy poruszone na Githubie Tink, luki wyskakujące tu i tam.

Jeśli masz jakieś pytania lub uwagi, zapraszamy do komentowania! Bezpieczeństwo zawsze się zmienia i musisz zrobić wszystko, aby nadążyć za nim:) [11]}

Thanks Ive made this class using your code maybe someone finds it userfull

Object crypter

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.ShortBufferException;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;


public class ObjectCrypter {

private Cipher deCipher;
private Cipher enCipher;
private SecretKeySpec key;
private IvParameterSpec ivSpec;


public ObjectCrypter(byte[] keyBytes,   byte[] ivBytes) {
    // wrap key data in Key/IV specs to pass to cipher


     ivSpec = new IvParameterSpec(ivBytes);
    // create the cipher with the algorithm you choose
    // see javadoc for Cipher class for more info, e.g.
    try {
         DESKeySpec dkey = new  DESKeySpec(keyBytes);
          key = new SecretKeySpec(dkey.getKey(), "DES");
         deCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
         enCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
    } catch (NoSuchAlgorithmException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (NoSuchPaddingException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (InvalidKeyException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
public byte[] encrypt(Object obj) throws InvalidKeyException, InvalidAlgorithmParameterException, IOException, IllegalBlockSizeException, ShortBufferException, BadPaddingException {
    byte[] input = convertToByteArray(obj);
    enCipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);

    return enCipher.doFinal(input);




//  cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);
//  byte[] encypted = new byte[cipher.getOutputSize(input.length)];
//  int enc_len = cipher.update(input, 0, input.length, encypted, 0);
//  enc_len += cipher.doFinal(encypted, enc_len);
//  return encypted;


}
public Object decrypt( byte[]  encrypted) throws InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException, IOException, ClassNotFoundException {
    deCipher.init(Cipher.DECRYPT_MODE, key, ivSpec);

    return convertFromByteArray(deCipher.doFinal(encrypted));

}



private Object convertFromByteArray(byte[] byteObject) throws IOException,
        ClassNotFoundException {
    ByteArrayInputStream bais;

    ObjectInputStream in;
    bais = new ByteArrayInputStream(byteObject);
    in = new ObjectInputStream(bais);
    Object o = in.readObject();
    in.close();
    return o;

}



private byte[] convertToByteArray(Object complexObject) throws IOException {
    ByteArrayOutputStream baos;

    ObjectOutputStream out;

    baos = new ByteArrayOutputStream();

    out = new ObjectOutputStream(baos);

    out.writeObject(complexObject);

    out.close();

    return baos.toByteArray();

}


}

A może tak:

private static byte[] xor(final byte[] input, final byte[] secret) {
    final byte[] output = new byte[input.length];
    if (secret.length == 0) {
        throw new IllegalArgumentException("empty security key");
    }
    int spos = 0;
    for (int pos = 0; pos < input.length; ++pos) {
        output[pos] = (byte) (input[pos] ^ secret[spos]);
        ++spos;
        if (spos >= secret.length) {
            spos = 0;
        }
    }
    return output;
}

Działa dobrze dla mnie i jest raczej Kompaktowy.

Oto moja realizacja z meta64.com jako wiosenny Singleton. Jeśli chcesz utworzyć instancję ciper dla każdego połączenia, które również będzie działać, a następnie możesz usunąć 'zsynchronizowane' połączenia, ale uważaj 'cipher' nie jest bezpieczny dla wątków.

import java.security.Key;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("singleton")
public class Encryptor {

    @Value("${aeskey}")
    private String keyStr;

    private Key aesKey = null;
    private Cipher cipher = null;

    synchronized private void init() throws Exception {
        if (keyStr == null || keyStr.length() != 16) {
            throw new Exception("bad aes key configured");
        }
        if (aesKey == null) {
            aesKey = new SecretKeySpec(keyStr.getBytes(), "AES");
            cipher = Cipher.getInstance("AES");
        }
    }

    synchronized public String encrypt(String text) throws Exception {
        init();
        cipher.init(Cipher.ENCRYPT_MODE, aesKey);
        return toHexString(cipher.doFinal(text.getBytes()));
    }

    synchronized public String decrypt(String text) throws Exception {
        init();
        cipher.init(Cipher.DECRYPT_MODE, aesKey);
        return new String(cipher.doFinal(toByteArray(text)));
    }

    public static String toHexString(byte[] array) {
        return DatatypeConverter.printHexBinary(array);
    }

    public static byte[] toByteArray(String s) {
        return DatatypeConverter.parseHexBinary(s);
    }

    /*
     * DO NOT DELETE
     * 
     * Use this commented code if you don't like using DatatypeConverter dependency
     */
    // public static String toHexStringOld(byte[] bytes) {
    // StringBuilder sb = new StringBuilder();
    // for (byte b : bytes) {
    // sb.append(String.format("%02X", b));
    // }
    // return sb.toString();
    // }
    //
    // public static byte[] toByteArrayOld(String s) {
    // int len = s.length();
    // byte[] data = new byte[len / 2];
    // for (int i = 0; i < len; i += 2) {
    // data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i +
    // 1), 16));
    // }
    // return data;
    // }
}

Rozważyłbym użycie czegoś w rodzaju https://www.bouncycastle.org/ jest to wbudowana biblioteka, która pozwala na szyfrowanie, co chcesz, za pomocą wielu różnych Szyfrów Rozumiem, że chcesz tylko chronić przed szpiegowaniem, ale jeśli naprawdę chcesz chronić informacje, korzystanie z Base64 nie ochroni Cię.

Oto kilka linków, które możesz przeczytać co obsługuje Java

Szyfrowanie / deszyfrowanie strumienia danych.

Ten przykład pokazuje jak encrypt (za pomocą szyfrowania symetrycznego algorytmy takie jak AES, Blowfish, RC2, 3DES, itp.) duża ilość danych. Na dane przekazywane są w kawałkach do jednego z metody szyfrowania: EncryptBytes, EncryptString, EncryptBytesENC lub EncryptStringENC. (Nazwa metody wskazuje typ wejścia (string lub tablica bajtów) oraz Typ zwrotu (zakodowany łańcuch lub tablica bajtów). Na Właściwości FirstChunk i LastChunk są używane do wskazania, czy fragment jest pierwszym, środkowym lub ostatnim w strumień do zaszyfrowania. Domyślnie, zarówno FirstChunk jak i LastChunk są równe true - co oznacza, że dane przekazane to cała kwota.

JCERefGuide

Przykłady Szyfrowania Java

Możesz użyć Jasypt

Z Jasypt, szyfrowanie i sprawdzanie hasła może być tak proste, jak...

StrongTextEncryptor textEncryptor = new StrongTextEncryptor();
textEncryptor.setPassword(myEncryptionPassword);

Szyfrowanie:

String myEncryptedText = textEncryptor.encrypt(myText);

Deszyfrowanie:

String plainText = textEncryptor.decrypt(myEncryptedText);

Gradle:

compile group: 'org.jasypt', name: 'jasypt', version: '1.9.2'

Cechy:

Jasypt zapewnia łatwe jednokierunkowe (digest) i dwukierunkowe techniki szyfrowania.

Otwarte API do użytku z dowolnym dostawcą JCE, a nie tylko domyślną maszyną Wirtualną Java. Jasypt może być łatwo używany ze znanymi dostawcami, takimi jak dmuchany zamek. Dowiedz się więcej.

Większe bezpieczeństwo haseł użytkowników. Dowiedz się więcej.

Obsługa szyfrowania binarnego. Jasypt umożliwia digest i szyfrowanie binariów (macierzy bajtowych). Szyfruj obiekty lub pliki w razie potrzeby(na przykład do przesyłania przez sieć).

Obsługa szyfrowania numerów. Oprócz tekstów i binariów, pozwala na digest i szyfrowanie wartości liczbowych (BigInteger i BigDecimal, inne typy liczbowe są obsługiwane podczas szyfrowania dla trwałości Hibernate). Dowiedz się więcej.

Całkowicie bezpieczny dla wątków.

Wsparcie dla szyfrowania / digester pooling, w celu osiągnięcia wysokiej wydajności w systemach wieloprocesorowych / wielordzeniowych.

Zawiera lekką ("lite") wersję biblioteki dla lepszego zarządzania w środowiskach ograniczających Rozmiar, takich jak platformy mobilne.

Zapewnia zarówno łatwe, bez konfiguracji narzędzia szyfrowania dla nowych użytkowników szyfrowanie, a także wysoce konfigurowalne standardowe narzędzia szyfrowania, dla zaawansowanych użytkowników.

Opcjonalna integracja Hibernate 3 i 4 dla utrzymujących się pól zmapowanych jednostek w zaszyfrowany sposób. Szyfrowanie pól jest zdefiniowane w plikach mapowania Hibernate i pozostaje przezroczyste dla reszty aplikacji (przydatne dla wrażliwych danych osobowych, baz danych z wieloma użytkownikami z możliwością odczytu...). Szyfruj teksty, binaria, liczby, booleany, daty... Dowiedz się więcej.

Bezproblemowa integracja z aplikacją sprężynową, ze specjalnymi funkcjami integracji dla Spring 2, Spring 3.0 i Spring 3.1. Wszystkie dygestory i szyfratory w jasypt są zaprojektowane tak, aby można je było łatwo używać (instantiated, dependency-injected...) od wiosny. A ze względu na to, że są bezpieczne dla wątków, mogą być używane bez obaw o synchronizację w środowisku singletonowym, takim jak Spring. Więcej informacji: wiosna 2, Wiosna 3.0, Wiosna 3.1.

Spring Security (dawniej Acegi Security) opcjonalna integracja w celu wykonywania szyfrowania haseł i dopasowywania zadań do ram bezpieczeństwa, poprawa bezpieczeństwa haseł użytkowników poprzez zastosowanie bezpieczniejszych mechanizmów szyfrowania haseł i zapewnienie wyższego stopnia konfiguracji i kontroli. Dowiedz się więcej.

Zapewnia zaawansowane funkcje szyfrowania wszystkich lub części plików konfiguracyjnych aplikacji, w tym poufnych informacji, takich jak hasła do bazy danych. Bezproblemowa integracja szyfrowanej konfiguracji do zwykłych, opartych na źródle i/lub hibernowanych aplikacji. Dowiedz się więcej.

Zapewnia łatwe w użyciu narzędzia CLI (Command Line Interface), aby umożliwić programistom inicjalizację ich zaszyfrowanych danych i obejmują operacje szyfrowania/deszyfrowania / digest w zadaniach konserwacyjnych lub skryptach. Dowiedz się więcej.

Integruje się z Apache Wicket, aby zapewnić bardziej niezawodne szyfrowanie adresów URL w bezpiecznych aplikacjach.

Obszerne przewodniki i dokumentacja javadoc, aby umożliwić programistom lepiej zrozumieć, co tak naprawdę robią z ich danymi.

Solidna obsługa zestawów znaków, zaprojektowana do odpowiedniego szyfrowania i trawienia tekstów niezależnie od tego, jaki jest oryginalny zestaw znaków. Pełne wsparcie dla języków takich jak japoński, koreański, arabski... bez problemów z kodowaniem i platformą.

Bardzo wysoki poziom możliwości konfiguracyjnych: programista może zaimplementować sztuczki, takie jak polecenie "szyfrującego", aby poprosił na przykład zdalny serwer HTTPS o hasło, które ma być użyte do szyfrowania. Pozwala zaspokoić Twoje potrzeby w zakresie bezpieczeństwa.

Tutaj proste rozwiązanie z tylko java.* i javax.crypto.* zależnościami do szyfrowania bajtów zapewniających poufnośći integralność. Musi być nie do odróżnienia pod wybranym atakiem zwykłego tekstu.

Używa AES w trybie GCM bez wypełnienia, 128-bitowy klucz jest wyprowadzany przez PBKDF2 z dużą ilością iteracji i statyczną solą z podanego hasła. To sprawia, że brutalne wymuszanie haseł jest trudne i rozkłada entropię na cały klucz.

Generowany jest losowy wektor inicjalizacji (IV), który będzie poprzedzony tekstem szyfrowym. Co więcej, bajt statyczny 0x01 jest poprzedzany jako pierwszy bajt jako 'wersja'.

Cała wiadomość przechodzi do kodu uwierzytelniania wiadomości (MAC) wygenerowanego przez AES/GCM.

Oto idzie, zero zewnętrznych zależności Klasa szyfrowania zapewniająca poufność i integralność :

package cryptor;

import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;

/**
 * This class implements AES-GCM symmetric key encryption with a PBKDF2 derived password.
 * It provides confidentiality and integrity of the plaintext.
 *
 * @created 2018-02-25
 */
public class AesGcmCryptor {

    // https://crypto.stackexchange.com/questions/26783/ciphertext-and-tag-size-and-iv-transmission-with-aes-in-gcm-mode
    private static final byte VERSION_BYTE = 0x01;
    private static final int VERSION_BYTE_LENGTH = 1;
    private static final int AES_KEY_BITS_LENGTH = 128;
    private static final int GCM_IV_BYTES_LENGTH = 12;
    private static final int GCM_TAG_BYTES_LENGTH = 16;

    private static final int PBKDF2_ITERATIONS = 16384;

    private static final byte[] PBKDF2_SALT = hexStringToByteArray("4d3fe0d71d2abd2828e7a3196ea450d4");

    /**
     * Decrypts an AES-GCM encrypted ciphertext and is
     * the reverse operation of {@link AesGcmCryptor#encrypt(char[], byte[])}
     *
     * @param password   passphrase for decryption
     * @param ciphertext encrypted bytes
     *
     * @return plaintext bytes
     *
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws NoSuchProviderException
     * @throws InvalidKeySpecException
     * @throws InvalidAlgorithmParameterException
     * @throws InvalidKeyException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     * @throws IllegalArgumentException           if the length or format of the ciphertext is bad
     */
    public byte[] decrypt(char[] password, byte[] ciphertext)
            throws NoSuchPaddingException, NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException,
            InvalidAlgorithmParameterException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException,
            BadVersionException {

        // input validation
        if (ciphertext == null) {
            throw new IllegalArgumentException("Ciphertext cannot be null.");
        }

        if (ciphertext.length <= VERSION_BYTE_LENGTH + GCM_IV_BYTES_LENGTH + GCM_TAG_BYTES_LENGTH) {
            throw new IllegalArgumentException("Ciphertext too short.");
        }

        // the version must match, we don't decrypt other versions
        if (ciphertext[0] != VERSION_BYTE) {
            throw new BadVersionException();
        }

        // input seems legit, lets decrypt and check integrity

        // derive key from password
        SecretKey key = deriveAesKey(password, PBKDF2_SALT, AES_KEY_BITS_LENGTH);

        // init cipher
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "SunJCE");
        GCMParameterSpec params = new GCMParameterSpec(GCM_TAG_BYTES_LENGTH * 8,
                ciphertext,
                VERSION_BYTE_LENGTH,
                GCM_IV_BYTES_LENGTH
        );
        cipher.init(Cipher.DECRYPT_MODE, key, params);

        final int ciphertextOffset = VERSION_BYTE_LENGTH + GCM_IV_BYTES_LENGTH;

        // add version and IV to MAC
        cipher.updateAAD(ciphertext, 0, ciphertextOffset);

        // decipher and check MAC
        return cipher.doFinal(ciphertext, ciphertextOffset, ciphertext.length - ciphertextOffset);
    }

    /**
     * Encrypts a plaintext with a password.
     *
     * The encryption provides the following security properties:
     * Confidentiality + Integrity
     *
     * This is achieved my using the AES-GCM AEAD blockmode with a randomized IV.
     *
     * The tag is calculated over the version byte, the IV as well as the ciphertext.
     *
     * Finally the encrypted bytes have the following structure:
     * <pre>
     *          +-------------------------------------------------------------------+
     *          |         |               |                             |           |
     *          | version | IV bytes      | ciphertext bytes            |    tag    |
     *          |         |               |                             |           |
     *          +-------------------------------------------------------------------+
     * Length:     1B        12B            len(plaintext) bytes            16B
     * </pre>
     * Note: There is no padding required for AES-GCM, but this also implies that
     * the exact plaintext length is revealed.
     *
     * @param password  password to use for encryption
     * @param plaintext plaintext to encrypt
     *
     * @throws NoSuchAlgorithmException
     * @throws NoSuchProviderException
     * @throws NoSuchPaddingException
     * @throws InvalidAlgorithmParameterException
     * @throws InvalidKeyException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     * @throws InvalidKeySpecException
     */
    public byte[] encrypt(char[] password, byte[] plaintext)
            throws NoSuchAlgorithmException, NoSuchProviderException, NoSuchPaddingException,
            InvalidAlgorithmParameterException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException,
            InvalidKeySpecException {

        // initialise random and generate IV (initialisation vector)
        SecretKey key = deriveAesKey(password, PBKDF2_SALT, AES_KEY_BITS_LENGTH);
        final byte[] iv = new byte[GCM_IV_BYTES_LENGTH];
        SecureRandom random = SecureRandom.getInstanceStrong();
        random.nextBytes(iv);

        // encrypt
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "SunJCE");
        GCMParameterSpec spec = new GCMParameterSpec(GCM_TAG_BYTES_LENGTH * 8, iv);
        cipher.init(Cipher.ENCRYPT_MODE, key, spec);

        // add IV to MAC
        final byte[] versionBytes = new byte[] { VERSION_BYTE };
        cipher.updateAAD(versionBytes);
        cipher.updateAAD(iv);

        // encrypt and MAC plaintext
        byte[] ciphertext = cipher.doFinal(plaintext);

        // prepend VERSION and IV to ciphertext
        byte[] encrypted = new byte[1 + GCM_IV_BYTES_LENGTH + ciphertext.length];
        int pos = 0;
        System.arraycopy(versionBytes, 0, encrypted, 0, VERSION_BYTE_LENGTH);
        pos += VERSION_BYTE_LENGTH;
        System.arraycopy(iv, 0, encrypted, pos, iv.length);
        pos += iv.length;
        System.arraycopy(ciphertext, 0, encrypted, pos, ciphertext.length);

        return encrypted;
    }

    /**
     * We derive a fixed length AES key with uniform entropy from a provided
     * passphrase. This is done with PBKDF2/HMAC256 with a fixed count
     * of iterations and a provided salt.
     *
     * @param password passphrase to derive key from
     * @param salt     salt for PBKDF2 if possible use a per-key salt, alternatively
     *                 a random constant salt is better than no salt.
     * @param keyLen   number of key bits to output
     *
     * @return a SecretKey for AES derived from a passphrase
     *
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    private SecretKey deriveAesKey(char[] password, byte[] salt, int keyLen)
            throws NoSuchAlgorithmException, InvalidKeySpecException {

        if (password == null || salt == null || keyLen <= 0) {
            throw new IllegalArgumentException();
        }
        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
        KeySpec spec = new PBEKeySpec(password, salt, PBKDF2_ITERATIONS, keyLen);
        SecretKey pbeKey = factory.generateSecret(spec);

        return new SecretKeySpec(pbeKey.getEncoded(), "AES");
    }

    /**
     * Helper to convert hex strings to bytes.
     *
     * May be used to read bytes from constants.
     */
    private static byte[] hexStringToByteArray(String s) {

        if (s == null) {
            throw new IllegalArgumentException("Provided `null` string.");
        }

        int len = s.length();
        if (len % 2 != 0) {
            throw new IllegalArgumentException("Invalid length: " + len);
        }

        byte[] data = new byte[len / 2];
        for (int i = 0; i < len - 1; i += 2) {
            byte b = (byte) toHexDigit(s, i);
            b <<= 4;
            b |= toHexDigit(s, i + 1);
            data[i / 2] = b;
        }
        return data;
    }

    private static int toHexDigit(String s, int pos) {
        int d = Character.digit(s.charAt(pos), 16);
        if (d < 0) {
            throw new IllegalArgumentException("Cannot parse hex digit: " + s + " at " + pos);
        }
        return d;
    }
}

Tutaj cały projekt z ładnym CLI: https://github.com/trichner/tcrypt

To metoda, której użyłem.jest to proste, ale ma lepszą ochronę. https://github.com/chamikaras/simpleEncryptor

Przeczytaj readme w tym projekcie.Jest to proste w użyciu.

public SimpleEncryptor(int MaximumLength) {
    //initialize encryption Key pattern variable
    pattern = new Integer[MaximumLength];
    //Generate pattern
    pattern =GenarateEncryptionPattern(MaximumLength);
}

private Integer[] GenarateEncryptionPattern(int Length) {
    Integer[] randomPattern = new Integer[Length];
    //generate encryption pattern
    for (int i = 0; i < Length; i++) {
        //make random encrypt key
        Random random = new Random();
        randomPattern[i] = random.nextInt(9);
    }
    return randomPattern;
}

public void simpleEncryptData(String data) {

    for (int i=0; i<data.length();i++){
        //get character from data
        char character = data.charAt(i);
        //convert character to ascii
        int ascii = (int) character;
        //decrypt data with random generated text
        int encryptedascii = ascii + pattern[i];
        //convert ascii to char
        char encryptedchar = (char)encryptedascii;
        //append string with char
        encryptedData += encryptedchar;

    }
}

private String convertKey(){
    //convert key to String
    String key = "";
    for (int i = 0;i<pattern.length;i++){
        key += String.valueOf(pattern[i]);
    }
  return key;
}


public String getDecryptData(String data, String key){
    String decryptedData = "";
    for (int i=0;i<data.length();i++){
        //get current key from decryptkey
        String number = key.substring(i,i+1);
        //get char from encrypeddata
        char encryptedchar = data.charAt(i);
        //convert char to ascii
        int encryptedascii = (char)encryptedchar;
        //decrypt encrypted char
        int decryptedascii = encryptedascii - Integer.valueOf(number);
        //convert ascii to char
        char decryptedchar = (char)decryptedascii;
        //append decrypted string
        decryptedData += decryptedchar;
    }
    return decryptedData;
}
public String getDecryptData(String data, Integer[] key){
    String decryptedData = "";
    for (int i=0;i<data.length();i++){
        //get char from encrypeddata
        char encryptedchar = data.charAt(i);
        //convert char to ascii
        int encryptedascii = (char)encryptedchar;
        //decrypt encrypted char
        int decryptedascii = encryptedascii - key[i];
        //convert ascii to char
        char decryptedchar = (char)decryptedascii;
        //append decrypted string
        decryptedData += decryptedchar;
    }
    return decryptedData;
}

public String getEncryptedData(){
    //return encryptedData
    return encryptedData;
}
public Integer[] getRawDecryptKey(){
    //return rawkey
    return pattern;
}
public String getStringDecryptKey(){
    //return string key
    return convertKey();
}

}

Jak wielu facetów już powiedziało, powinieneś użyć standardowego cyphera, który jest zbyt używany, jak DES lub AES.

Prosty przykład jak można zaszyfrować i odszyfrować łańcuch znaków w Javie za pomocą AES .

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class EncryptorDemo {

    public static String encrypt(String key, String randomVector, String value) {
        try {
            IvParameterSpec iv = new IvParameterSpec(randomVector.getBytes("UTF-8"));
            SecretKeySpec skeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "AES");
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
            byte[] encrypted = cipher.doFinal(value.getBytes());
            System.out.println("encrypted text: "  + Base64.encodeBase64String(encrypted));
            return Base64.encodeBase64String(encrypted);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String decrypt(String key, String randomVector, String encrypted) {
        try {
            IvParameterSpec iv = new IvParameterSpec(randomVector.getBytes("UTF-8"));
            SecretKeySpec skeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "AES");
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
            cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
            byte[] originalText = cipher.doFinal(Base64.decodeBase64(encrypted));
            System.out.println("decrypted text: "  + new String(originalText));
            return new String(originalText);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void main(String[] args) {
        String key = "JavasEncryptDemo"; // 128 bit key
        String randomVector = "RandomJavaVector"; // 16 bytes IV
        decrypt(key, randomVector, encrypt(key, randomVector, "Anything you want to encrypt!"));

    }
}

String s1="arshad"; 
char[] s2=s1.toCharArray(); 
int s3= s2.length; 

  System.out.println(s3);
 int i=0; 

// for(int j=0;j<s3;j++) 
// System.out.println(s2[j]); 

for(i=0;i<((s3)/2);i++) { 

char z,f=10; 
z=(char) (s2[i] * f); 
s2[i]=s2[(s3-1)-i]; 
s2[(s3-1)-i]=z; 

String b=new String(s2);

 print(b);  }

Warto rozważyć jakieś zautomatyzowane narzędzie do generowania kodu szyfrującego / deszyfrującego, np. https://www.stringencrypt.com/java-encryption/

Może generować za każdym razem inny kod szyfrowania i deszyfrowania dla szyfrowania łańcuchów lub plików.

Jest to bardzo przydatne, jeśli chodzi o szybkie szyfrowanie ciągów bez użycia RSA, AES itp.

Przykładowe wyniki:

// encrypted with https://www.stringencrypt.com (v1.1.0) [Java]
// szTest = "Encryption in Java!"
String szTest = "\u9E3F\uA60F\uAE07\uB61B\uBE1F\uC62B\uCE2D\uD611" +
                "\uDE03\uE5FF\uEEED\uF699\uFE3D\u071C\u0ED2\u1692" +
                "\u1E06\u26AE\u2EDC";

for (int iatwS = 0, qUJQG = 0; iatwS < 19; iatwS++)
{
        qUJQG = szTest.charAt(iatwS);
        qUJQG ++;
        qUJQG = ((qUJQG << 5) | ( (qUJQG & 0xFFFF) >> 11)) & 0xFFFF;
        qUJQG -= iatwS;
        qUJQG = (((qUJQG & 0xFFFF) >> 6) | (qUJQG << 10)) & 0xFFFF;
        qUJQG ^= iatwS;
        qUJQG -= iatwS;
        qUJQG = (((qUJQG & 0xFFFF) >> 3) | (qUJQG << 13)) & 0xFFFF;
        qUJQG ^= 0xFFFF;
        qUJQG ^= 0xB6EC;
        qUJQG = ((qUJQG << 8) | ( (qUJQG & 0xFFFF) >> 8)) & 0xFFFF;
        qUJQG --;
        qUJQG = (((qUJQG & 0xFFFF) >> 5) | (qUJQG << 11)) & 0xFFFF;
        qUJQG ++;
        qUJQG ^= 0xFFFF;
        qUJQG += iatwS;
        szTest = szTest.substring(0, iatwS) + (char)(qUJQG & 0xFFFF) + szTest.substring(iatwS + 1);
}

System.out.println(szTest);

public static String encryptParams(String myTextInput) {

        String myKey = "40674244454045cb9a70040a30e1c007";
        String myVector = "@1B2c3D4e5F6g7H8";

        String encData = "";

        try{
            JavaEncryprtionUtil encUtil = new JavaEncryprtionUtil();
            encData = Base64.encodeToString(encUtil.encrypt(myTextInput.getBytes("UTF-8"), myKey.getBytes("UTF-8"), myVector.getBytes("UTF-8")),Base64.DEFAULT);
            System.out.println(encData);
        }catch(NoSuchAlgorithmException ex){
            ex.printStackTrace();
        }catch(NoSuchPaddingException ex){
            ex.printStackTrace();
        }catch(InvalidKeyException ex){
            ex.printStackTrace();
        }catch(InvalidAlgorithmParameterException ex){
            ex.printStackTrace();
        }catch(IllegalBlockSizeException ex){
            ex.printStackTrace();
        }catch(BadPaddingException ex){
            ex.printStackTrace();
        }catch(UnsupportedEncodingException ex){
            ex.printStackTrace();
        }

        return encData;
    }