How to implement the Des32 key in java by golang

ask God for help in decrypting. I tried to use either an 8-byte key or a 24-byte key in golang to ask for help 

package com.mycompany.mavenproject1;

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
 
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.DESKeySpec;
/**
 * DES
 * 
 * @author WJ
 * @date 2015-08-30
 */
public class DESUtil {
    
    public static void main(String[] args) {
        
        try {
            //
            String password="Z*$Mcs8CcNd*Z0Ly-sharpw$nOYSlV!kEhJKM";
            DESUtil d=new DESUtil(password);
            String mingwen=d.decrypt("CuaxeOT+9klIuHTvjqggsw==");            
            System.out.println(mingwen);
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    /**  */
    private String keyData ="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCZklMmyKm122gYEyOdA9zqR7a3TIb8VyAI9U8M9qLXzK3j0V49UsyNM3Kwxj8Bw0OGKyx4hUVfgJzf8QyYxXOwguooQmX1bma7twGVhimGLBymxoxku6TbV8OTvoKD4OlByoPhfrO+MbM6O42XGvXBX+qrQctzdQAxy3kUziTxUQIDAQAB";
    /**
     * :
     * 
     * @author WJ
     * @date 2015-08-30
     */
    public DESUtil() {
    }
 
    /**
     * :
     * 
     * @author WJ
     * @date 2015-08-30
     * @param keyData
     *      key
     */
    public DESUtil(String key) {
        this.keyData = key;
    }
 
    /**
     * : (UTF-8)
     * 
     * @author WJ
     * @date 2015-08-30
     * @param source
     *      
     * @param charSet
     *      
     * @return String
     * @throws UnsupportedEncodingException
     *       
     */
    public String encrypt(String source) throws UnsupportedEncodingException {
        return encrypt(source, "UTF-8");
    }
 
    /**
     * 
     * : (UTF-8)
     * 
     * @author WJ
     * @date 2015-08-30
     * @param encryptedData
     *      
     * @return String
     * @throws UnsupportedEncodingException
     *       
     */
    public String decrypt(String encryptedData)
            throws UnsupportedEncodingException {
        return decrypt(encryptedData, "UTF-8");
    }
 
    /**
     * :
     * 
     * @author WJ
     * @date 2015-08-30
     * @param source
     *      
     * @param charSet
     *      
     * @return String
     * @throws UnsupportedEncodingException
     *       
     */
    public String encrypt(String source, String charSet)
            throws UnsupportedEncodingException {
        String encrypt = null;
        byte[] ret = encrypt(source.getBytes(charSet));
        encrypt = new String(Base64.encode(ret));
        return encrypt;
    }
 
    /**
     * 
     * :
     * 
     * @author WJ
     * @date 2015-08-30
     * @param encryptedData
     *      
     * @param charSet
     *      
     * @return String
     * @throws UnsupportedEncodingException
     *       
     */
    public String decrypt(String encryptedData, String charSet)
            throws UnsupportedEncodingException {
        String descryptedData = null;
        byte[] ret = descrypt(Base64.decode(encryptedData.toCharArray()));
        descryptedData = new String(ret, charSet);
        return descryptedData;
    }
 
    /**
     *  
     * 
     * @param primaryData
     *      
     * @return byte[]
     * @author WJ
     * @date 2015-08-30
     */
    private byte[] encrypt(byte[] primaryData) {
 
        /**  */
 
        /** DES */
        SecureRandom sr = new SecureRandom();
 
        /** DESKeySpec */
        DESKeySpec dks = null;
        try {
            dks = new DESKeySpec(keyData.getBytes());
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }
 
        /**  */
        SecretKeyFactory keyFactory = null;
        try {
            keyFactory = SecretKeyFactory.getInstance("DES");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
 
        /** DESKeySpecSecretKey */
        SecretKey key = null;
        try {
            key = keyFactory.generateSecret(dks);
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
 
        /** Cipher */
        Cipher cipher = null;
        try {
            cipher = Cipher.getInstance("DES");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        }
 
        /** Cipher */
        try {
            cipher.init(Cipher.ENCRYPT_MODE, key, sr);
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }
 
        /**  */
        byte encryptedData[] = null;
        try {
            encryptedData = cipher.doFinal(primaryData);
        } catch (IllegalStateException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }
 
        /**  */
        return encryptedData;
    }
 
    /**
     * 
     * 
     * @param encryptedData
     *      
     * @return byte[]
     * @author WJ
     * @date 2015-08-30
     */
    private byte[] descrypt(byte[] encryptedData) {
 
        /** DES */
        SecureRandom sr = new SecureRandom();
 
        /**  */
 
        /** DESKeySpec */
        DESKeySpec dks = null;
        try {
            dks = new DESKeySpec(keyData.getBytes());
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }
 
        /**  */
        SecretKeyFactory keyFactory = null;
        try {
            keyFactory = SecretKeyFactory.getInstance("DES");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
 
        /** DESKeySpecSecretKey */
        SecretKey key = null;
        try {
            key = keyFactory.generateSecret(dks);
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
 
        /** Cipher */
        Cipher cipher = null;
        try {
            cipher = Cipher.getInstance("DES");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        }
 
        /** Cipher */
        try {
            cipher.init(Cipher.DECRYPT_MODE, key, sr);
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }
 
        /**  */
        byte decryptedData[] = null;
        try {
            decryptedData = cipher.doFinal(encryptedData);
        } catch (IllegalStateException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }
 
        return decryptedData;
    }

 
}
package com.mycompany.mavenproject1;

import java.io.*;
/**
 * Base64 
 * 
 * @author 
 * @date 20140703
 */
public class Base64 {
 
    public Base64() {
    }
 
    /**
     * :
     * 
     * @author 
     * @date 20140703
     * @param data
     *      
     * @return String
     */
    public static String encode(String data) {
        return new String(encode(data.getBytes()));
    }
 
    /**
     * :
     * 
     * @author 
     * @date 20140703
     * @param data
     *      
     * @return String
     */
    public static String decode(String data) {
        return new String(decode(data.toCharArray()));
    }
 
    /**
     * :byte[]
     * 
     * @author 
     * @date 20140703
     * @param data
     *      
     * @return char[]
     */
    public static char[] encode(byte[] data) {
        char[] out = new char[((data.length + 2) / 3) * 4];
        for (int i = 0, index = 0; i < data.length; i += 3, index += 4) {
            boolean quad = false;
            boolean trip = false;
 
            int val = (0xFF & (int) data[i]);
            val <<= 8;
            if ((i + 1) < data.length) {
                val |= (0xFF & (int) data[i + 1]);
                trip = true;
            }
            val <<= 8;
            if ((i + 2) < data.length) {
                val |= (0xFF & (int) data[i + 2]);
                quad = true;
            }
            out[index + 3] = alphabet[(quad ? (val & 0x3F) : 64)];
            val >>= 6;
            out[index + 2] = alphabet[(trip ? (val & 0x3F) : 64)];
            val >>= 6;
            out[index + 1] = alphabet[val & 0x3F];
            val >>= 6;
            out[index + 0] = alphabet[val & 0x3F];
        }
        return out;
    }
 
    /**
     * :
     * 
     * @author 
     * @date 20140703
     * @param data
     *      
     * @return byte[]
     */
    public static byte[] decode(char[] data) {
        int tempLen = data.length;
        for (int ix = 0; ix < data.length; ixPP) {
            if ((data[ix] > 255) || codes[data[ix]] < 0) {
                --tempLen; // ignore non-valid chars and padding
            }
        }
        // calculate required length:
        // -- 3 bytes for every 4 valid base64 chars
        // -- plus 2 bytes if there are 3 extra base64 chars,
        // or plus 1 byte if there are 2 extra.
 
        int len = (tempLen / 4) * 3;
        if ((tempLen % 4) == 3) {
            len += 2;
        }
        if ((tempLen % 4) == 2) {
            len += 1;
 
        }
        byte[] out = new byte[len];
 
        int shift = 0; // -sharp of excess bits stored in accum
        int accum = 0; // excess bits
        int index = 0;
 
        // we now go through the entire array (NOT using the "tempLen" value)
        for (int ix = 0; ix < data.length; ixPP) {
            int value = (data[ix] > 255) ? -1 : codes[data[ix]];
 
            if (value >= 0) { // skip over non-code
                accum <<= 6; // bits shift up by 6 each time thru
                shift += 6; // loop, with new bits being put in
                accum |= value; // at the bottom.
                if (shift >= 8) { // whenever there are 8 or more shifted in,
                    shift -= 8; // write them out (from the top, leaving any
                    out[indexPP] = // excess at the bottom for next iteration.
                    (byte) ((accum >> shift) & 0xff);
                }
            }
        }
 
        // if there is STILL something wrong we just have to throw up now!
        if (index != out.length) {
            throw new Error("Miscalculated data length (wrote " + index
                    + " instead of " + out.length + ")");
        }
        for (int i = 0; i < out.length; iPP) {
//            System.err.println("i:"+i + "   ---->"+out);
            for (byte b : out) {
                System.out.println("b:"+b);
            }
        }
        return out;
    }
 
    /**
     * :
     * 
     * @author 
     * @date 20140703
     * @param file
     *      
     */
    public static void encode(File file) throws IOException {
        if (!file.exists()) {
            System.exit(0);
        }
 
        else {
            byte[] decoded = readBytes(file);
            char[] encoded = encode(decoded);
            writeChars(file, encoded);
        }
        file = null;
    }
 
    /**
     * :
     * 
     * @author 
     * @date 20140703
     * @param file
     *      
     * @throws IOException
     */
    public static void decode(File file) throws IOException {
        if (!file.exists()) {
            System.exit(0);
        } else {
            char[] encoded = readChars(file);
            byte[] decoded = decode(encoded);
            writeBytes(file, decoded);
        }
        file = null;
    }
 
    //
    // code characters for values 0..63
    //
    private static char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
            .toCharArray();
 
    //
    // lookup table for converting base64 characters to value in range 0..63
    //
    private static byte[] codes = new byte[256];
    static {
        for (int i = 0; i < 256; iPP) {
            codes[i] = -1;
            // LoggerUtil.debug(i + "&" + codes[i] + " ");
        }
        for (int i = "A"; i <= "Z"; iPP) {
            codes[i] = (byte) (i - "A");
            // LoggerUtil.debug(i + "&" + codes[i] + " ");
        }
 
        for (int i = "a"; i <= "z"; iPP) {
            codes[i] = (byte) (26 + i - "a");
            // LoggerUtil.debug(i + "&" + codes[i] + " ");
        }
        for (int i = "0"; i <= "9"; iPP) {
            codes[i] = (byte) (52 + i - "0");
            // LoggerUtil.debug(i + "&" + codes[i] + " ");
        }
        codes["+"] = 62;
        codes["/"] = 63;
    }
 
    private static byte[] readBytes(File file) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] b = null;
        InputStream fis = null;
        InputStream is = null;
        try {
            fis = new FileInputStream(file);
            is = new BufferedInputStream(fis);
            int count = 0;
            byte[] buf = new byte[16384];
            while ((count = is.read(buf)) != -1) {
                if (count > 0) {
                    baos.write(buf, 0, count);
                }
            }
            b = baos.toByteArray();
 
        } finally {
            try {
                if (fis != null)
                    fis.close();
                if (is != null)
                    is.close();
                if (baos != null)
                    baos.close();
            } catch (Exception e) {
                System.out.println(e);
            }
        }
 
        return b;
    }
 
    private static char[] readChars(File file) throws IOException {
        CharArrayWriter caw = new CharArrayWriter();
        Reader fr = null;
        Reader in = null;
        try {
            fr = new FileReader(file);
            in = new BufferedReader(fr);
            int count = 0;
            char[] buf = new char[16384];
            while ((count = in.read(buf)) != -1) {
                if (count > 0) {
                    caw.write(buf, 0, count);
                }
            }
 
        } finally {
            try {
                if (caw != null)
                    caw.close();
                if (in != null)
                    in.close();
                if (fr != null)
                    fr.close();
            } catch (Exception e) {
                System.out.println(e);
            }
        }
 
        return caw.toCharArray();
    }
 
    private static void writeBytes(File file, byte[] data) throws IOException {
        OutputStream fos = null;
        OutputStream os = null;
        try {
            fos = new FileOutputStream(file);
            os = new BufferedOutputStream(fos);
            os.write(data);
 
        } finally {
            try {
                if (os != null)
                    os.close();
                if (fos != null)
                    fos.close();
            } catch (Exception e) {
                System.out.println(e);
            }
        }
    }
 
    private static void writeChars(File file, char[] data) throws IOException {
        Writer fos = null;
        Writer os = null;
        try {
            fos = new FileWriter(file);
            os = new BufferedWriter(fos);
            os.write(data);
 
        } finally {
            try {
                if (os != null)
                    os.close();
                if (fos != null)
                    fos.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
 
    // /////////////////////////////////////////////////
    // end of test code.
    // /////////////////////////////////////////////////
 
}
Des golang
May.11,2021

have you solved it, please?
public String encryptByte (byte [] byteS) {

    byte[] byteFina = null;
    Cipher cipher;
    BASE64Encoder base64en = new BASE64Encoder();
    String strMi = "";
    try {
        cipher = Cipher.getInstance("DES");

        cipher.init(Cipher.ENCRYPT_MODE, getKey(appkey));

        byteFina = cipher.doFinal(byteS);
        System.out.println(Arrays.toString(byteFina));
        strMi = base64en.encode(byteFina);
    } catch (Exception e) {
        throw new RuntimeException(
                "Error initializing SqlMap class. Cause: " + e);
    } finally {
        cipher = null;
    }
    return strMi;
}


private static Key getKey(String strKey) {
    try {
        SecureRandom _secureRandom = SecureRandom.getInstance("SHA1PRNG");
        _secureRandom.setSeed(strKey.getBytes());
        KeyGenerator kg = null;
        kg = KeyGenerator.getInstance(DES_ALGORITHM);
        System.out.println(_secureRandom.toString());
        kg.init(_secureRandom);
        return kg.generateKey();
    } catch (Exception e) {
        throw new RuntimeException(
                "Error initializing SqlMap class. Cause: " + e);
    }
}

Previous: Conflict occurs when expandedRowRender and onexpand,expandedRowKeys, are used at the same time?!

Next: Vant lead-in component error report

css mysql arrays josn react html typescript webpack npm sass R objective-c .net sql-server jquery python-3.x angularjs django angular excel regex iphone ajax linux xml pandas vba spring database wordpress string wpf xcode windows bash postgresql oracle multithreading eclipse list firebase algorithm macos forms image scala visual-studio azure bootstrap spring-boot react-native python-2.7 docker performance function winforms matlab powershell apache dataframe api sqlite numpy rest shell selenium flutter dart maven loops qt swing android-studio csv express file class tensorflow sorting codeigniter perl
© 2021 CodesHelper
Advertising Contact us About us
Menu