Programación JAVA: Hacemos tus proyectos de Sistemas: Encriptacion

AES y DES
Los siguientes códigos que implementé para codificar datos importantes en un proyecto con base de datos, estos son estándares muy conocidos y seguros. Estos 2 algoritmos servirán para encriptar datos como contraseñas de usuario y otros datos que no queremos sean vistos por intrusos o hackers en caso de ataques a nuestra base de datos. Es una medida de seguridad que nunca esta de mas.
Diseñados por JJMM

AES

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
public class AESBasic {

private String KeyPass="";
private String ALGORITHM = "AES";
private int LENGTH = 128;
private String TEXTFORMAT = "UTF-8";
private AESKey AESK=new AESKey();

public AESBasic() {
        try {
            AESK=this.KeyGenerate();
        } catch (Exception ex) {
            Logger.getLogger(AESBasic.class.getName()).log(Level.SEVERE, null, ex);
        }
}

public AESBasic(String Pass) {
        try {
            AESK=this.KeyGenerate();
            KeyPass=this.genKey(Pass);
            AESK.setEncoded(KeyPass);
        } catch (Exception ex) {
            Logger.getLogger(AESBasic.class.getName()).log(Level.SEVERE, null, ex);
        }
}

private AESKey KeyGenerate(){
        try {
            KeyGenerator Keygen = KeyGenerator.getInstance(ALGORITHM);
            Keygen.init(LENGTH);
            SecretKey SecKey = Keygen.generateKey();
            AESKey aesKey = new AESKey();
            aesKey.setEncoded(HexToString(SecKey.getEncoded()));
            KeyPass=aesKey.getEncoded();
            return aesKey;
        } catch (NoSuchAlgorithmException ex) {
            Logger.getLogger(AESBasic.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
}

public String genKey(String pass){
        return KeyPass=getStringBytes(StringToBytes(pass));
    }
 
    private byte[] StringToBytes(String str){
        try {
            byte [] b;
            byte [] Baux;
            b=str.getBytes("UTF-8");
            while(b.length<32){
                Baux=new byte[(32-b.length)+b.length];
                for(int i=0;i<Baux.length;i++){
                    if(i<b.length){
                        Baux[i]=b[i];
                    }else{
                        if(i%2==0){
                        Baux[i]="JJMMAES".getBytes()[2];
                        }else{
                        Baux[i]="AESJJMM".getBytes()[0];
                        }
                    }
                }
                b=Baux;
            }
         
            return b;
        } catch (UnsupportedEncodingException ex) {
        }
        return null;
    }
 
    private String getStringBytes(byte [] b){
       String str="";
       for(int i=0;i<b.length;i++){
           str=str+b[i];
       }
       return str.substring(0,32);
    }

public String Encode(String str){
        try {
            byte[] raw = StringToHex(KeyPass);
            SecretKeySpec skeySpec = new SecretKeySpec(raw, ALGORITHM);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
            byte[] encrypted = cipher.doFinal(str.getBytes(TEXTFORMAT));
            String encript = HexToString(encrypted);
            return encript;
        } catch (Exception ex) {
            return null;
        }
}

public String Decode(String str){
        try {
            byte[] raw = StringToHex(KeyPass);
            SecretKeySpec skeySpec = new SecretKeySpec(raw, ALGORITHM);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, skeySpec);
            byte[] original = cipher.doFinal(StringToHex(str));
            String originalString = new String(original);
            return originalString;
        } catch (Exception ex) {
            return null;
        }
}

public String getKey(){
    return AESK.getEncoded();
}

public void setKey(String K){
    AESK.setEncoded(K);
}

private String HexToString(byte[] array) {
 
    String text = "";
    for (int i = 0; i < array.length; i++) {
        int aux = array[i] & 0xff;
        if (aux < 16) {
        text = text.concat("0");
        }
        text = text.concat(Integer.toHexString(aux));
    }
 
    return text;
}

private byte[] StringToHex(String text) {
    byte[] array = new byte[text.length() / 2];
    for (int i = 0; i < array.length; i++) {
        int index = i * 2;
        String aux = text.substring(index, index + 2);
        int v = Integer.parseInt(aux, 16);
        array[i] = (byte) v;
    }
 
    return array;
}

private class AESKey {
 
    private String encoded;
     
    public String getEncoded() {
            return encoded;
    }

public void setEncoded(String encoded) {
    this.encoded = encoded;
    }
 
 
}
 
 
 
}

DES

import java.io.UnsupportedEncodingException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.IvParameterSpec;

public class DESBasic {

private Cipher Encipher;
private Cipher Decipher;
private String Algorithm = "DESede";
private String Transformer = "DESede/CBC/PKCS5Padding";
private String SKeyPass = "123456789012345678901234"; //your SKeyPass 24 bit
private SecretKey SKey;
private IvParameterSpec IV;

public DESBasic(String pass) {
        try {
            SKeyPass=this.genSKey(pass);
            DESedeKeySpec SKeySpec = new DESedeKeySpec(SKeyPass.getBytes());
            SKey = SecretKeyFactory.getInstance(Algorithm).generateSecret(SKeySpec);
            IV = new IvParameterSpec(new byte[8]);
            Encipher = Cipher.getInstance(Transformer);
            Decipher = Cipher.getInstance(Transformer);
            Encipher.init(Cipher.ENCRYPT_MODE, SKey, IV);
            Decipher.init(Cipher.DECRYPT_MODE, SKey, IV);
        } catch (Exception ex) {
            Logger.getLogger(DESBasic.class.getName()).log(Level.SEVERE, null, ex);
        }

}

public String Encode(String str) {
try {
byte[] enc = Encipher.doFinal(str.getBytes());
return this.HexToString(enc);
} catch (Exception e) {
}
return null;
}

public String Decode(String str) {
try {
byte[] utf8 = Decipher.doFinal(StringToHex(str));
return new String(utf8, "UTF8");
} catch (Exception e) {
}
return null;
}

public String genSKey(String pass){
        return this.getStringBytes(StringToBytes(pass));
    }

private byte[] StringToBytes(String str){
        try {
            byte [] b;
            byte [] Baux;
            b=str.getBytes("UTF-8");
            while(b.length<32){
                Baux=new byte[(32-b.length)+b.length];
                for(int i=0;i<Baux.length;i++){
                    if(i<b.length){
                        Baux[i]=b[i];
                    }else{
                        if(i%2==0){
                        Baux[i]="JJMMDES".getBytes()[1];
                        }else{
                        Baux[i]="JJMMDES".getBytes()[5];
                        }
                    }
                }
                b=Baux;
            }
         
            return b;
        } catch (UnsupportedEncodingException ex) {
            Logger.getLogger(SuperDecrypt.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }
 
    private String getStringBytes(byte [] b){
       String str="";
       for(int i=0;i<b.length;i++){
           str=str+b[i];
       }
       return str.substring(0,48);
    }

}

Programación JAVA: Hacemos tus proyectos de Sistemas

domingo, marzo 30, 2014

JScreenLock: Bloquear escritorio en Java

lunes, agosto 05, 2013

Texto Encriptado con AES y DES