DES (Data Encryption Standard) - ECB: Duvida em guardar a keygen

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.*;
import javax.crypto.*;
 
 public class Class {
     
     private static SecretKey desKey = null;
     private static byte[] key = null;
     
     public static SecretKey getKeyGen(){
         
         if(desKey==null){
             KeyGenerator keygen=null;
             try {
                 keygen = KeyGenerator.getInstance("DES");
                 desKey = keygen.generateKey();
             } catch (NoSuchAlgorithmException e) {
                 e.printStackTrace();
             }
            
             return desKey;
         }
         
         return desKey;
     }
     
     public static String encripta(String dado) throws GeneralSecurityException{
         
         Cipher enCipher;
         // Criando o Cipher
         enCipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
         //Iniciando o cipher
         enCipher.init(Cipher.WRAP_MODE, Class.getKeyGen());
         key = enCipher.wrap(Class.getKeyGen()); //Guardando a chave
         enCipher.init(Cipher.ENCRYPT_MODE, Class.getKeyGen());
         /*Byte do dado a ser criptografado*/
         byte[] dados = null;
		try {
			dados = dado.getBytes("UTF8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
         /*O dado já criptografado*/
         byte[] dadoEncriptado = enCipher.doFinal(dados);
         
         return new sun.misc.BASE64Encoder().encode(dadoEncriptado);
     }
     
     public static String decripta(String dadoEncriptado) throws GeneralSecurityException, UnsupportedEncodingException{
                 
         Cipher desCipher;
         
         // Criando o Cipher
         desCipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
                 
         // Os dados criptografados para descriptografar
         byte[] dadoDescriptografado=null;
         try {
			dadoDescriptografado = new sun.misc.BASE64Decoder().decodeBuffer(dadoEncriptado);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
 
         // Inicializando o cipher e pegando a minha chave para descripografar
         desCipher.init(Cipher.UNWRAP_MODE,Class.getKeyGen());
         desCipher.init(Cipher.DECRYPT_MODE,desCipher.unwrap(key,"DES",Cipher.SECRET_KEY));
         // Descriptografando
         byte[] texto = desCipher.doFinal(dadoDescriptografado);
         
         return new String(texto,"UTF8");
         
     }
     public static void main(String args[]){
         String dado = "Minha informação";
         String en = null;
         String des = null;
         System.out.println("String antes: "+dado);
         try {
             en =  Class.encripta(dado);
           
         } catch (GeneralSecurityException e) {
                   e.printStackTrace();
         } 
         System.out.println("String criptografada: "+en);
               
         try {
             try {
				des = Class.decripta(en);
			} catch (UnsupportedEncodingException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
         } catch (GeneralSecurityException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         System.out.println("String Descriptografada: "+des);
         System.out.println("Key utilizada: "+new String(key));
       }
 }

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.spec.*;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.KeySpec;

public final class TestePBE {
	private static SecretKey skey;
	private static final String algorithm = "AES/CBC/PKCS5Padding";
	public static final void encrypt(char[] password, File arq)
		throws  IOException, 
			BadPaddingException,
			NoSuchPaddingException,
			IllegalBlockSizeException,
			InvalidKeyException,
			NoSuchAlgorithmException {
        	SecretKeyFactory skf = SecretKeyFactory.getInstance(algorithm);
		KeySpec ks = new PBEKeySpec (password, new byte[]{1,2,3,4,5,6,7,8,9,10}, 1000);
		SecretKey skey = skf.generateSecret (ks);
		final Cipher cipher = Cipher.getInstance(algorithm);
		cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
		return cipher.doFinal(text.getBytes());
	}
	public static final void decrypt(char[] password, File arq)
		throws  IOException,
			BadPaddingException,
			NoSuchPaddingException,
			IllegalBlockSizeException,
			InvalidKeyException,
			NoSuchAlgorithmException {
		SecretKeyFactory skf = SecretKeyFactory.getInstance(algorithm);
		KeySpec ks = new PBEKeySpec (password, new byte[]{1,2,3,4,5,6,7,8,9,10}, 1000);
		SecretKey skey = skf.generateSecret (ks);
		final Cipher cipher = Cipher.getInstance(algorithm);
		cipher.init(Cipher.DECRYPT_MODE, skeySpec);
		return cipher.doFinal(text.getBytes());
	}
	
	private static int tamArquivoTeste = 12345;
	
	private static void geraArquivoTeste(File arq) throws IOException {
	    Random r = new Random ();
	    r.setSeed (123456789);
	    byte[] bytes = new byte[tamArquivoTeste];
	    r.next (bytes);
	    OutputStream os = new FileOutputStream (arq);
	    os.write (bytes);
	    os.close();
        }
        
	private static boolean confereArquivoTeste(File arq) throws IOException {
	    boolean ret = true;
	    Random r = new Random ();
	    r.setSeed (123456789);
	    byte[] bytes = new byte[tamArquivoTeste];
	    r.next (bytes);
	    byte[] readBytes = new byte[tamArquivoTeste];
	    if (arq.length() != tamArquivoTeste) {
	        System.out.println ("Arquivo de tamanho diferente do esperado");
	        return false;
            }
	    InputStream is = new FileInputStream (arq);
	    int nBytes = is.read (readBytes);
	    is.close();
	    
	    if (nBytes != tamArquivoTeste) {
	        System.out.println ("Arquivo de tamanho diferente do esperado");
	        return false;
            }
            return Arrays.equals (readBytes, bytes);
        }
	
	public static void main(String[] args) throws Exception {
            String password = "senha altamente secreta";
            File arqEntrada = new File ("teste.bin");
            File arqCifrado = new File ("teste.bin.cifrado");
            File arqDecifrado = new File ("teste.bin.decifrado");
            geraArquivoTeste (arqTeste);		
            TestePBE.encrypt (password, arqEntrada, arqCifrado);
            //-- Checando com a senha certa
            TestePBE.decrypt (password, arqCifrado, arqDecifrado);
            if (confereArquivoTeste (arqEntrada, arqDecifrado)) {
                System.out.println ("Os arquivos bateram");
            }
            //-- Checando com a senha errada
            TestePBE.decrypt ("senhaErrada", arqTeste);
            if (confereArquivoTeste (arqEntrada, arqDecifrado)) {
                System.out.println ("Os arquivos bateram");
            }
	}
}