Java :: Aufgabe #116
2 Lösungen
Base64 - Kodierung/-Dekodierung
Fortgeschrittener - Java
von devnull
- 14.03.2016 um 14:42 Uhr
Base64 ist ein Verfahren zur Kodierung von 8-Bit-Binärdaten und wird häufig zum Kodieren von Email-Anhängen verwendet.
Schreibe wahlweise einen Base64-Encoder oder einen Base64-Decoder. Wer Lust hat, kann natürlich auch beide Funktionen in einem Programm kombinieren.
Schreibe wahlweise einen Base64-Encoder oder einen Base64-Decoder. Wer Lust hat, kann natürlich auch beide Funktionen in einem Programm kombinieren.
Lösungen:
Hier meine Lösung.
Beim Decoden hätte man das Auflösen der tatsächlichen Stellen die ausgegeben werden schöner lösen können aber naja...
Und ja die ArrayLists am Anfang sind schön :)
MAIN:
Java-Code
SechsBit:
Java-Code
AchtBit:
Java-Code
Kodierer:
Java-Code
Beim Decoden hätte man das Auflösen der tatsächlichen Stellen die ausgegeben werden schöner lösen können aber naja...
Und ja die ArrayLists am Anfang sind schön :)
MAIN:
Java-Codepackage de.littlef;
import java.util.ArrayList;
import java.util.Scanner;
public class Base64 {
private static Scanner sc = new Scanner(System.in);
private static Kodierer kodierer = new Kodierer();
private static String sInput;
private static String sOutput;
private static int iAnzahlBytes;
private static int iFuell;
private static ArrayList<AchtBit> liAchtBit = new ArrayList<AchtBit>();
private static final String sFuell = "00000000";
public static void main(String[] args) {
// Input:
System.out.println("Bitte geben Sie Ihre zu verschlüsselnde Bytes ein:");
sInput = sc.nextLine();
sc.close();
// Anzahl der Bytes ausrechnen:
iAnzahlBytes = sInput.length() / 8;
// Eventuell FüllBytes anheften:
if (iAnzahlBytes % 3 == 1) {
sInput += sFuell;
sInput += sFuell;
iFuell = 2;
} else if (iAnzahlBytes % 3 == 2) {
sInput += sFuell;
iFuell = 1;
} else {
iFuell = 0;
}
// Input in AchtBit Liste übertragen:
for (int i = 0; i < sInput.length(); i += 8) {
AchtBit temp = new AchtBit(sInput.substring(i, i + 8));
liAchtBit.add(temp);
}
for (int i = 0; i < liAchtBit.size(); i++) {
}
// Kodieren lassen:
sOutput = kodierer.encode(liAchtBit,iFuell);
// Kodiert ausgeben:
System.out.println("Kodierter Text:\n" + sOutput);
// Dekodieren lassen:
System.out.println("Dekodierter Text:\n"+kodierer.decode(sOutput,iAnzahlBytes));
}
}
SechsBit:
Java-Codepackage de.littlef;
public class SechsBit {
private String sSechsBit;
public SechsBit(String x){
setSechsBit(x);
}
private void setSechsBit(String x){
sSechsBit = x;
}
public String getSechsBit(){
return sSechsBit;
}
}
AchtBit:
Java-Codepackage de.littlef;
public class AchtBit {
private String sAchtBit;
public AchtBit(String x){
setAchtBit(x);
}
private void setAchtBit(String x){
sAchtBit = x;
}
public String getAchtBit(){
return sAchtBit;
}
}
Kodierer:
Java-Codepackage de.littlef;
import java.util.ArrayList;
public class Kodierer {
@SuppressWarnings("serial")
private static final ArrayList<String> codeSechsBit = new ArrayList<String>() {
{
// 32-16-8-4-2-1
add("111111");
add("111110");
add("111101");
add("111100");
add("111011");
add("111010");
add("111001");
add("111000");
add("110111");
add("110110");
add("110101");
add("110100");
add("110011");
add("110010");
add("110001");
add("110000");
add("101111");
add("101110");
add("101101");
add("101100");
add("101011");
add("101010");
add("101001");
add("101000");
add("100111");
add("100110");
add("100101");
add("100100");
add("100011");
add("100010");
add("100001");
add("100000");
add("011111");
add("011110");
add("011101");
add("011100");
add("011011");
add("011010");
add("011001");
add("011000");
add("010111");
add("010110");
add("010101");
add("010100");
add("010011");
add("010010");
add("010001");
add("010000");
add("001111");
add("001110");
add("001101");
add("001100");
add("001011");
add("001010");
add("001001");
add("001000");
add("000111");
add("000110");
add("000101");
add("000100");
add("000011");
add("000010");
add("000001");
add("000000");
}
};
@SuppressWarnings("serial")
private static final ArrayList<String> codeZeichen = new ArrayList<String>() {
{
add("/");
add("+");
add("9");
add("8");
add("7");
add("6");
add("5");
add("4");
add("3");
add("2");
add("1");
add("0");
add("z");
add("y");
add("x");
add("w");
add("v");
add("u");
add("t");
add("s");
add("r");
add("q");
add("p");
add("o");
add("n");
add("m");
add("l");
add("k");
add("j");
add("i");
add("h");
add("g");
add("f");
add("e");
add("d");
add("c");
add("b");
add("a");
add("Z");
add("Y");
add("X");
add("W");
add("V");
add("U");
add("T");
add("S");
add("R");
add("Q");
add("P");
add("O");
add("N");
add("M");
add("L");
add("K");
add("J");
add("I");
add("H");
add("G");
add("F");
add("E");
add("D");
add("C");
add("B");
add("A");
}
};
private ArrayList<String> liSechsBit = new ArrayList<String>();
private String s24Bit;
private String encoded;
private String decoded;
private int iFuell;
// Kodieren
public String encode(ArrayList<AchtBit> toEncode, int iF) {
iFuell = iF;
encoded = "";
// 24Bit Sequenz erstellen
for (int i = 0; i < toEncode.size(); i += 3) {
s24Bit = "";
for (int j = 0; j < 3; j++) {
s24Bit += toEncode.get(i + j).getAchtBit();
}
// 24Bit Sequenz in 6Bit Sequenzen splitten
for (int j = 0; j < s24Bit.length(); j += 6) {
liSechsBit.add(s24Bit.substring(j, j + 6));
}
}
// liSechsBit Liste durchgehen und einzelne 6-Bit verschlüsseln
for (int i = 0; i < liSechsBit.size()-iFuell; i++) {
for (int j = 0; j < codeSechsBit.size(); j++) {
if (liSechsBit.get(i).equals(codeSechsBit.get(j))) {
encoded += codeZeichen.get(j);
}
}
}
//Fuellbytes mit = ersetzen
for (int i = 1; i <= iFuell; i++) {
encoded += "=";
}
return encoded;
}
//Dekodieren
public String decode(String encoded, int iSendBytes){
decoded="";
//Alle Stellen durchgehen und zuordnen ( =Fällt automatisch raus)
for (int i = 0; i < encoded.length(); i++) {
for (int j = 0; j < codeZeichen.size(); j++) {
if(encoded.substring(i,i+1).equals(codeZeichen.get(j))){
decoded += codeSechsBit.get(j);
}
}
}
return decoded.substring(0, 8*iSendBytes);
}
}
Java-Codeimport java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.SecretKeySpec;
/**
* 2016 © SiCuSoft Tutorials
* Simple Text Crypter AES, SHA-256
* www.sicusoft.at
* @author Etzelsdorfer Thomas
*/
public class AESJava {
private static Cipher cipher;
private static final String AES = "AES";
private static final String SHA_INSTANCE_256 = "SHA-256";
/**
* Konstruktor der Klasse mit der
* Initialisiertung des Cipher Objektes
*/
public AESJava() {
try {
AESJava.cipher = Cipher.getInstance(AES);
} catch (NoSuchAlgorithmException | NoSuchPaddingException ex) {
ex.printStackTrace();
}
}
/**
* Methode erstellt einen Key ({@link SecretKeySpec} aus einem übergebenen
* Passwort und gibt diesen Key zurück.
*
* @param password
* @return key
*/
public SecretKeySpec createStringKey(String password) {
SecretKeySpec key = null;
try {
byte[] keyByte = (password).getBytes("UTF-8");
MessageDigest sha = MessageDigest.getInstance(SHA_INSTANCE_256);
keyByte = sha.digest(keyByte);
keyByte = Arrays.copyOf(keyByte, 16);
key = new SecretKeySpec(keyByte, AES);
} catch (UnsupportedEncodingException | NoSuchAlgorithmException e) {
e.printStackTrace();
}
return key;
}
/**
* Methode verschlüsselt einen Text und gibt den Text zurück
*
* @param text normaler Text
* @param key schlüssel
* @return verschlüsselter Text
*/
public String encryptText(String text, SecretKeySpec key) {
String encodedText = "";
try {
cipher = Cipher.getInstance(AES);
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] encrypt = cipher.doFinal(text.getBytes());
Base64.Encoder encoder = Base64.getEncoder();
encodedText = encoder.encodeToString(encrypt);
} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException e) {
e.printStackTrace();
}
return encodedText;
}
/**
* Metode entschlüsselt den Text
*
* @param encodedText verschlüsselter Text
* @param key schlüssel
* @return entschlüsselter Text
*/
public String decryptText(String encodedText, SecretKeySpec key) {
String decodedText = "";
try {
Base64.Decoder decoder = Base64.getDecoder();
byte[] de = decoder.decode(encodedText);
cipher = Cipher.getInstance(AES);
cipher.init(Cipher.DECRYPT_MODE, key);
byte[] cipherData = cipher.doFinal(de);
decodedText = new String(cipherData);
} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException e) {
e.printStackTrace();
}
return decodedText;
}
}SiCuSoft, Thomas Etzelsdorfer