FinalShell密码解密

news/2024/11/8 0:37:14/

FinalShell,linux服务器修改密码后忘记密码，在配置文件中找到加密后的密码，可用下列方法解密

import org.apache.commons.codec.digest.DigestUtils;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.SecureRandom;
import java.util.Random;
public class getFinalShellPassword {
    public static long number = 3680984568597093857L;
    private static int num = 8;
    public static void main(String[] args) throws Exception {
        // 加密后的密码
        String s1 = "YUx7bRE2IGCLr4YqqETe5nLLxX3TltDn";
        String s2 = decode(s1);
        System.out.println("输入之前是：" + s1);
        System.out.println("破解之后是：" + s2);
    }
    public static String decode(String data) throws IOException, Exception {
        if (data == null) {
            return null;
        } else {
            String rs = "";
            if (!fff(data)) {
                byte[] buf = ggg(data);
                byte[] head = new byte[num];
                System.arraycopy(buf, 0, head, 0, head.length);
                byte[] d = new byte[buf.length - head.length];
                System.arraycopy(buf, head.length, d, 0, d.length);
                byte[] bt = jjj(d, kkk(head));
                rs = new String(bt);
            }
            return rs;
        }
    }
    public static String encode(String content) throws Exception {
        byte[] head = aaa(num);
        byte[] d = bbb(content.getBytes("utf-8"), head);
        byte[] result = new byte[head.length + d.length];
        System.arraycopy(head, 0, result, 0, head.length);
        System.arraycopy(d, 0, result, head.length, d.length);
        String rs = ccc(result);
        return rs;
    }
    static byte[] aaa(int len) {
        byte[] data = new byte[len];
        for (int i = 0; i < len; ++i) {
            data[i] = (byte) (new Random()).nextInt(127);
        }
        return data;
    }
    public static byte[] bbb(byte[] data, byte[] head) throws Exception {
        SecureRandom sr = new SecureRandom();
        DESKeySpec dks = new DESKeySpec(kkk(head));
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey securekey = keyFactory.generateSecret(dks);
        Cipher cipher = Cipher.getInstance("DES");
        cipher.init(1, securekey, sr);
        return cipher.doFinal(data);
    }
    public static String ccc(byte[] byteData) throws UnsupportedEncodingException {
        return ddd(byteData, "UTF-8");
    }
    public static String ddd(byte[] byteData, String encoding) throws UnsupportedEncodingException {
        if (byteData == null) {
            throw new IllegalArgumentException("byteData cannot be null");
        } else {
            return new String(eee(byteData), encoding);
        }
    }
    public static final byte[] eee(byte[] byteData) {
        if (byteData == null) {
            throw new IllegalArgumentException("byteData cannot be null");
        } else {
            byte[] byteDest = new byte[(byteData.length + 2) / 3 * 4];
            int iSrcIdx = 0;
            int iDestIdx;
            for (iDestIdx = 0; iSrcIdx < byteData.length - 2; iSrcIdx += 3) {
                byteDest[iDestIdx++] = (byte) (byteData[iSrcIdx] >>> 2 & 63);
                byteDest[iDestIdx++] = (byte) (byteData[iSrcIdx + 1] >>> 4 & 15 | byteData[iSrcIdx] << 4 & 63);
                byteDest[iDestIdx++] = (byte) (byteData[iSrcIdx + 2] >>> 6 & 3 | byteData[iSrcIdx + 1] << 2 & 63);
                byteDest[iDestIdx++] = (byte) (byteData[iSrcIdx + 2] & 63);
            }
            if (iSrcIdx < byteData.length) {
                byteDest[iDestIdx++] = (byte) (byteData[iSrcIdx] >>> 2 & 63);
                if (iSrcIdx < byteData.length - 1) {
                    byteDest[iDestIdx++] = (byte) (byteData[iSrcIdx + 1] >>> 4 & 15 | byteData[iSrcIdx] << 4 & 63);
                    byteDest[iDestIdx++] = (byte) (byteData[iSrcIdx + 1] << 2 & 63);
                } else {
                    byteDest[iDestIdx++] = (byte) (byteData[iSrcIdx] << 4 & 63);
                }
            }
            for (iSrcIdx = 0; iSrcIdx < iDestIdx; ++iSrcIdx) {
                if (byteDest[iSrcIdx] < 26) {
                    byteDest[iSrcIdx] = (byte) (byteDest[iSrcIdx] + 65);
                } else if (byteDest[iSrcIdx] < 52) {
                    byteDest[iSrcIdx] = (byte) (byteDest[iSrcIdx] + 97 - 26);
                } else if (byteDest[iSrcIdx] < 62) {
                    byteDest[iSrcIdx] = (byte) (byteDest[iSrcIdx] + 48 - 52);
                } else if (byteDest[iSrcIdx] < 63) {
                    byteDest[iSrcIdx] = 43;
                } else {
                    byteDest[iSrcIdx] = 47;
                }
            }
            while (iSrcIdx < byteDest.length) {
                byteDest[iSrcIdx] = 61;
                ++iSrcIdx;
            }
            return byteDest;
        }
    }
    public static boolean fff(String str) {
        if (str == null) {
            return true;
        } else {
            String s2 = str.trim();
            return s2.equals("");
        }
    }
    public static final byte[] ggg(String encoded) throws UnsupportedEncodingException {
        return hhh(encoded, "UTF-8");
    }
    public static final byte[] hhh(String encoded, String encoding) throws IllegalArgumentException, UnsupportedEncodingException {
        if (encoded == null) {
            throw new IllegalArgumentException("encoded cannot be null");
        } else {
            return iii(encoded.getBytes(encoding));
        }
    }
    public static final byte[] iii(byte[] byteData) throws IllegalArgumentException {
        if (byteData == null) {
            throw new IllegalArgumentException("byteData cannot be null");
        } else {
            byte[] byteTemp = new byte[byteData.length];
            int reviSrcIdx;
            for (reviSrcIdx = byteData.length; reviSrcIdx - 1 > 0 && byteData[reviSrcIdx - 1] == 61; --reviSrcIdx) {
            }
            if (reviSrcIdx - 1 == 0) {
                return null;
            } else {
                byte[] byteDest = new byte[reviSrcIdx * 3 / 4];
                int iSrcIdx;
                for (iSrcIdx = 0; iSrcIdx < reviSrcIdx; ++iSrcIdx) {
                    if (byteData[iSrcIdx] == 43) {
                        byteTemp[iSrcIdx] = 62;
                    } else if (byteData[iSrcIdx] == 47) {
                        byteTemp[iSrcIdx] = 63;
                    } else if (byteData[iSrcIdx] < 58) {
                        byteTemp[iSrcIdx] = (byte) (byteData[iSrcIdx] + 52 - 48);
                    } else if (byteData[iSrcIdx] < 91) {
                        byteTemp[iSrcIdx] = (byte) (byteData[iSrcIdx] - 65);
                    } else if (byteData[iSrcIdx] < 123) {
                        byteTemp[iSrcIdx] = (byte) (byteData[iSrcIdx] + 26 - 97);
                    }
                }
                iSrcIdx = 0;
                int iDestIdx;
                for (iDestIdx = 0; iSrcIdx < reviSrcIdx && iDestIdx < byteDest.length / 3 * 3; iSrcIdx += 4) {
                    byteDest[iDestIdx++] = (byte) (byteTemp[iSrcIdx] << 2 & 252 | byteTemp[iSrcIdx + 1] >>> 4 & 3);
                    byteDest[iDestIdx++] = (byte) (byteTemp[iSrcIdx + 1] << 4 & 240 | byteTemp[iSrcIdx + 2] >>> 2 & 15);
                    byteDest[iDestIdx++] = (byte) (byteTemp[iSrcIdx + 2] << 6 & 192 | byteTemp[iSrcIdx + 3] & 63);
                }
                if (iSrcIdx < reviSrcIdx) {
                    if (iSrcIdx < reviSrcIdx - 2) {
                        byteDest[iDestIdx++] = (byte) (byteTemp[iSrcIdx] << 2 & 252 | byteTemp[iSrcIdx + 1] >>> 4 & 3);
                        byteDest[iDestIdx++] = (byte) (byteTemp[iSrcIdx + 1] << 4 & 240 | byteTemp[iSrcIdx + 2] >>> 2 & 15);
                    } else {
                        if (iSrcIdx >= reviSrcIdx - 1) {
                            throw new IllegalArgumentException("Warning: 1 input bytes left to process. This was not Base64 input");
                        }
                        byteDest[iDestIdx++] = (byte) (byteTemp[iSrcIdx] << 2 & 252 | byteTemp[iSrcIdx + 1] >>> 4 & 3);
                    }
                }
                return byteDest;
            }
        }
    }
    public static byte[] jjj(byte[] data, byte[] key) throws Exception {
        SecureRandom sr = new SecureRandom();
        DESKeySpec dks = new DESKeySpec(key);
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey securekey = keyFactory.generateSecret(dks);
        Cipher cipher = Cipher.getInstance("DES");
        cipher.init(2, securekey, sr);
        return cipher.doFinal(data);
    }
    static byte[] kkk(byte[] head) {
        long ks = number / (long) (new Random((long) head[5])).nextInt(127);
        Random random = new Random(ks);
        int t = head[0];
        for (int i = 0; i < t; ++i) {
            random.nextLong();
        }
        long n = random.nextLong();
        Random r2 = new Random(n);
        long[] ld = new long[]{(long) head[4], r2.nextLong(), (long) head[7], (long) head[3], r2.nextLong(), (long) head[1], random.nextLong(), (long) head[2]};
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);
        long[] var15 = ld;
        int var14 = ld.length;
        for (int var13 = 0; var13 < var14; ++var13) {
            long l = var15[var13];
            try {
                dos.writeLong(l);
            } catch (IOException var18) {
                var18.printStackTrace();
            }
        }
        try {
            dos.close();
        } catch (IOException var17) {
            var17.printStackTrace();
        }
        byte[] keyData = bos.toByteArray();
        keyData = DigestUtils.md5(keyData);
        return keyData;
    }
}


http://www.ppmy.cn/news/839572.html

相关文章

W密码解密算法

W密码解密算法

栅栏密码 文章目录 栅栏密码条形栅栏密码加密算法解密算法 W形栅栏密码WWW加密算法设计WWW解密算法推导确定字符对各行的分配规则cnt数组定义"周期"如果 c n t p h a s e cnt_{phase} cntphase​是一个偶数如果 c n t p h a s e cnt_{phase} cntphase​是一个奇数奇数…
阅读更多...
C语言实现凯撒密码加解密

C语言实现凯撒密码加解密

凯撒密码 加密即把a-z或A-Z的字母向后移动n个字符实现加密&#xff0c;若n3的话&#xff0c;a对应d&#xff0c;z对应c&#xff0c;如此循环&#xff1b;解密刚好和加密相反&#xff0c;加密向后移动的话解密就向前移动。 加密的C代码如下&#xff1a; #include <stdio.h&…
阅读更多...
ctf密码学加解密

ctf密码学加解密

base编码&#xff1a; 在字符串后看到&#xff1a;&#xff0c;很可能是base64编码 编码格式base16大写字母A-F和0-9base32大写字母A-Z和数字2-7base58大小写字母和数字去除0(零)和O(大写o)、I(大写i)和l(小写L)base64大小写字母和数字0-9以及"" "/"base…
阅读更多...
凯撒密码加解密实现（python）

凯撒密码加解密实现（python）

Caesar&#xff08;凯撒密码&#xff09; 原理 凯撒密码&#xff08;Caesar&#xff09;加密时会将明文中的 每个字母 都按照其在字母表中的顺序向后&#xff08;或向前&#xff09;移动固定数目&#xff08;循环移动&#xff09;作为密文。例如&#xff0c;当偏移量是左移 3…
阅读更多...
维吉尼亚密码加解密

维吉尼亚密码加解密

西安电子科技大学Python程序设计上机实验——维吉尼亚密码加解密 维吉尼亚密码是使用一系列凯撒密码组成密码字母表的加密算法&#xff0c;属于多表密码的一种简单形式。为了生成密码&#xff0c;需要使用表格法。这一表格包括了 26 行字母表&#xff0c;每一行都由前一行向左…
阅读更多...
加密解密

加密解密

//加密解密 public class GF_Encrypt { /// <summary> /// DES加密 /// </summary> /// <param name"pToEncrypt">加密字符串</param> /// <param name"sKey">密钥</param> /// <returns></returns> publ…
阅读更多...
仿射密码解密（Affine Cipher）

仿射密码解密（Affine Cipher）

仿射密码是一种表单代换密码&#xff0c;字母表的每个字母相应的值使用一个简单的数学函数对应一个数值&#xff0c;再把对应数值转换成字母。 ABCDEFGHIJKLMNOPQRSTUVWXYZ012345678910111213141516171819202122232425 加密函数&#xff1a;E(x) (ax b) (mod m)&#xff0c…
阅读更多...
古典密码----仿射密码加解密

古典密码----仿射密码加解密

理论部分 仿射密码是移位密码的一个推广&#xff0c;其加密过程不仅包含移位操作&#xff0c;而且使用了乘法运算。与移位密码相同&#xff0c;仿射密码的明文空间M和密文空间C均为Z26&#xff0c;因此&#xff0c;在使用仿射密码体制对英文消息进行加密之前&#xff0c;需要在…
阅读更多...
最新文章

Copyright @ 2022~2023