精华内容
下载资源
问答
  • 简介常见的加密算法可分为三大类:对称加密,非对称加密和hash算法对称加密:加密和解密使用相同的密钥。DES、3DES、AES、Blowfish、IDEA、DESX、RC-4、RC-5...的主要适用于空间换时间MD5、HMAC、SHA、SHA-1、MD2、MD4...

    简介

    常见的加密算法可分为三大类:对称加密,非对称加密和hash算法

    对称加密:加密和解密使用相同的密钥。

    DES、3DES、AES、Blowfish、IDEA、DESX、RC-4、RC-5、RC-6

    非对成加密:加密和解密使用不同的密钥

    RSA、ECC、DSA

    hash算法:通过算法将值映射到表中一个位置来訪问记录,以加快查找的速度。的主要适用于空间换时间

    MD5、HMAC、SHA、SHA-1、MD2、MD4、HMAC-MD5、HMAC-SHA1

    具体的算法java实现

    详细的加密可参考SecretKeyFactory 加密过程中由于加密算结果方便展示这里采用base64进行编码

    hash算法详细可参考MessageDigest

    对称加密

    DES、3DES

    public static byte[] encrypt(byte[] datasource, String password) throws Exception {

    SecureRandom random = new SecureRandom();

    DESKeySpec desKey = new DESKeySpec(password.getBytes());

    //创建一个密钥工厂,然后用它把DESKeySpec转换成

    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");

    SecretKey securekey = keyFactory.generateSecret(desKey);

    //cipher对象世纪完成加密操作

    Cipher cipher = Cipher.getInstance("DES");

    //用密钥初始化cipher对象

    cipher.init(cipher.ENCRYPT_MODE, securekey, random);

    //现在,获取数据并加密

    //正式执行加密操作

    byte[] r = cipher.doFinal(datasource);

    return encoder.encode(r);

    }

    public static byte[] decrypt(byte[] src, String password) throws Exception {

    src = decoder.decode(src);

    //DES算法要求有一个可信任的随即数源

    SecureRandom random = new SecureRandom();

    DESKeySpec deskey = new DESKeySpec(password.getBytes("utf-8"));

    //创建一个密钥工厂

    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");

    //将DESKeySpec对象转换成secretKey对象

    SecretKey secretKey = keyFactory.generateSecret(deskey);

    //cipher对象世纪完成解密操作

    Cipher cipher = Cipher.getInstance("DES");

    cipher.init(cipher.DECRYPT_MODE, secretKey, random);

    return cipher.doFinal(src);

    }

    static final Base64.Decoder decoder = Base64.getDecoder();

    static final Base64.Encoder encoder = Base64.getEncoder();

    public static void main(String[] args) throws Exception {

    String str = "代价密数据";

    //长度是8的倍数

    String password = "1234567887654321";

    byte[] result = DES.encrypt(str.getBytes("utf-8"), password);

    System.out.println("加密后:" + new String(result, "utf-8"));

    // String baseStr = encoder.encodeToString(result);

    // System.out.println("base64加密des密文:" + baseStr);

    // byte[] resp = decoder.decode(baseStr.getBytes());

    // System.out.println("base解码des密文:" + new String(resp));

    byte[] decryResult = DES.decrypt(result, password);

    System.out.println("解密后:" + new String(decryResult));

    }

    AES

    public static byte[] encrypt(byte[] src, String password) throws Exception {

    SecretKeySpec keySpec = getSecretKeySpec(password);

    //创建一个密钥工厂,然后用它把DESKeySpec转换成

    //cipher对象世纪完成加密操作

    Cipher cipher = Cipher.getInstance("AES");

    //用密钥初始化cipher对象

    cipher.init(cipher.ENCRYPT_MODE, keySpec);

    //现在,获取数据并加密

    //正式执行加密操作

    byte[] r = cipher.doFinal(src);

    return encoder.encode(r);

    }

    public static byte[] decrypt(byte[] src, String password) throws Exception {

    src = decoder.decode(src);

    SecretKeySpec keySpec = getSecretKeySpec(password);

    //创建一个密钥工厂,然后用它把DESKeySpec转换成

    //cipher对象世纪完成加密操作

    Cipher cipher = Cipher.getInstance("AES");

    //用密钥初始化cipher对象

    cipher.init(cipher.DECRYPT_MODE, keySpec);

    //现在,获取数据并加密

    //正式执行加密操作

    byte[] r = cipher.doFinal(src);

    return r;

    }

    private static SecretKeySpec getSecretKeySpec(String password) throws Exception {

    KeyGenerator kgen = KeyGenerator.getInstance("AES");

    SecureRandom random = SecureRandom.getInstance("SHA1PRNG");

    random.setSeed(password.getBytes());

    kgen.init(128, random);

    SecretKey secretKey = kgen.generateKey();

    SecretKeySpec keySpec = new SecretKeySpec(secretKey.getEncoded(), "AES");

    return keySpec;

    }

    static final Base64.Decoder decoder = Base64.getDecoder();

    static final Base64.Encoder encoder = Base64.getEncoder();

    public static void main(String[] args) throws Exception {

    String str = "代价密的书记和阿萨德法";

    System.out.println("加密前:" + str);

    //长度是8的倍数

    String password = "1234567890123456";

    byte[] result = AES.encrypt(str.getBytes(), password);

    System.out.println("加密后:" + new String(result));

    byte[] decryResult = AES.decrypt(result, password);

    System.out.println("解密后:" + new String(decryResult));

    }

    非对称加密

    RSA 引文rsa有长度限制 所以这里进行了数据进行分段加密

    private static String RSA = "RSA";

    private static final String CIPHER_INSTANCE = "RSA/ECB/PKCS1Padding";

    static final Base64.Decoder decoder = Base64.getDecoder();

    static final Base64.Encoder encoder = Base64.getEncoder();

    public static Map getKeys(int len) throws NoSuchAlgorithmException {

    KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA);

    kpg.initialize(len);

    KeyPair keyPair = kpg.generateKeyPair();

    Key publicKey = keyPair.getPublic();

    Key privateKey = keyPair.getPrivate();

    String pubKey = encoder.encodeToString(publicKey.getEncoded());

    String priKey = encoder.encodeToString(privateKey.getEncoded());

    Map resultMap = new HashMap<>();

    resultMap.put("publicKey", pubKey);

    resultMap.put("privateKey", priKey);

    return resultMap;

    }

    public static RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {

    KeyFactory keyFactory = KeyFactory.getInstance(RSA);

    X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decoder.decode(publicKey));

    RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(keySpec);

    return key;

    }

    public static RSAPrivateKey getPrivateKey(String privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {

    KeyFactory keyFactory = KeyFactory.getInstance(RSA);

    PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decoder.decode(privateKey));

    RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(keySpec);

    return key;

    }

    private static final String CHARSET_UTF_8 = "UTF-8";

    public static String publicEncrypt(String data, RSAPublicKey publicKey) throws Exception {

    Cipher cipher = Cipher.getInstance(CIPHER_INSTANCE);

    cipher.init(Cipher.ENCRYPT_MODE, publicKey);

    return encoder.encodeToString(rsaCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET_UTF_8), publicKey.getModulus().bitLength()));

    }

    public static String privateDecrypt(String data, RSAPrivateKey privateKey) throws Exception {

    Cipher cipher = Cipher.getInstance(CIPHER_INSTANCE);

    cipher.init(Cipher.DECRYPT_MODE, privateKey);

    return new String(rsaCodec(cipher, Cipher.DECRYPT_MODE, decoder.decode(data), privateKey.getModulus().bitLength()), CHARSET_UTF_8);

    }

    public static String privateEncrypt(String data, RSAPrivateKey privateKey) throws Exception {

    Cipher cipher = Cipher.getInstance(CIPHER_INSTANCE);

    cipher.init(Cipher.ENCRYPT_MODE, privateKey);

    return encoder.encodeToString(rsaCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET_UTF_8), privateKey.getModulus().bitLength()));

    }

    public static String publicDecrypt(String data, RSAPublicKey publicKey) throws Exception {

    Cipher cipher = Cipher.getInstance(CIPHER_INSTANCE);

    cipher.init(Cipher.DECRYPT_MODE, publicKey);

    return new String(rsaCodec(cipher, Cipher.DECRYPT_MODE, decoder.decode(data), publicKey.getModulus().bitLength()));

    }

    private static byte[] rsaCodec(Cipher cipher, int opmode, byte[] data, int keySize) throws Exception {

    int maxBlock = 0;

    if (opmode == Cipher.DECRYPT_MODE) {

    maxBlock = keySize / 8;

    } else {

    maxBlock = keySize / 8 - 11;

    }

    ByteArrayOutputStream out = new ByteArrayOutputStream();

    int offSet = 0;

    byte[] buff;

    int i = 0;

    while (data.length > offSet) {

    if (data.length - offSet > maxBlock) {

    buff = cipher.doFinal(data, offSet, maxBlock);

    } else {

    buff = cipher.doFinal(data, offSet, data.length - offSet);

    }

    out.write(buff, 0, buff.length);

    i++;

    offSet = i * maxBlock;

    }

    byte[] resultData = out.toByteArray();

    out.close();

    return resultData;

    }

    public static void main(String[] args) throws Exception {

    Map keyMap = getKeys(1024);

    String publicKey = keyMap.get("publicKey");

    String privateKey = keyMap.get("privateKey");

    System.out.println("公钥:\n" + publicKey);

    System.out.println("私钥:\n" + privateKey);

    String data = "打开了发动机卡拉决定翻开了解放法赛季的开罗附近阿克萨拉丁教父卡角色快乐的房间卡拉斯决定开罗附近阿斯克里的解放卡拉斯酒店客房法思考的解放卡拉祭祀坑的反抗拉斯蒂芬巴角色等级阿vjaklvlzxjlcvjlkx 卡拉角色的开罗附近阿喀琉斯的发送到解放卡角色的看法";

    System.out.println("明文:\n" + data);

    System.out.println("明文大小:\n" + data.getBytes().length);

    String encodeData = publicEncrypt(data, getPublicKey(publicKey));

    System.out.println("密文:\n" + encodeData);

    String decodeData = privateDecrypt(encodeData, getPrivateKey(privateKey));

    System.out.println("解密:\n" + decodeData);

    }

    DSA

    public static byte[] sign(byte[] src, byte[] dsaPrivateKey) throws Exception {

    PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(dsaPrivateKey);

    KeyFactory keyFactory = KeyFactory.getInstance("DSA");

    PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

    Signature signature = Signature.getInstance("SHA1withDSA");

    signature.initSign(privateKey);

    signature.update(src);

    byte[] res = signature.sign();

    return encoder.encode(res);

    }

    static final Base64.Decoder decoder = Base64.getDecoder();

    static final Base64.Encoder encoder = Base64.getEncoder();

    public static boolean verify(byte[] src,byte[] sign, byte[] dsaPublicKey) throws Exception {

    sign= decoder.decode(sign);

    X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(dsaPublicKey);

    KeyFactory keyFactory = KeyFactory.getInstance("DSA");

    PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);

    Signature signature = Signature.getInstance("SHA1withDSA");

    signature.initVerify(publicKey);

    signature.update(src);

    return signature.verify(sign);

    }

    public static void main(String[] args) throws Exception {

    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DSA");

    keyPairGenerator.initialize(512);

    KeyPair keyPair = keyPairGenerator.generateKeyPair();

    DSAPublicKey dsaPublicKey = (DSAPublicKey) keyPair.getPublic();

    DSAPrivateKey dsaPrivateKey = (DSAPrivateKey) keyPair.getPrivate();

    System.out.println("public:" + dsaPublicKey);

    System.out.println("private:" + dsaPublicKey);

    String str = "123456";

    byte[] sign = sign(str.getBytes("utf-8"), dsaPrivateKey.getEncoded());

    System.out.println("签名:" + new String(sign));

    boolean r = verify(str.getBytes(),sign, dsaPublicKey.getEncoded());

    System.out.println("验证签名:" + r);

    }

    private static String SRC_TEST = "dsa security";

    public static void test() throws Exception {

    // 1.初始化密钥

    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DSA");

    keyPairGenerator.initialize(512);

    KeyPair keyPair = keyPairGenerator.generateKeyPair();

    DSAPublicKey dsaPublicKey = (DSAPublicKey) keyPair.getPublic();

    DSAPrivateKey dsaPrivateKey = (DSAPrivateKey) keyPair.getPrivate();

    // 2.执行签名

    PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(dsaPrivateKey.getEncoded());

    KeyFactory keyFactory = KeyFactory.getInstance("DSA");

    PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

    Signature signature = Signature.getInstance("SHA1withDSA");

    signature.initSign(privateKey);

    signature.update(SRC_TEST.getBytes());

    byte[] res = signature.sign();

    System.out.println("签名:" + new String(res));

    // 3.验证签名

    X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(dsaPublicKey.getEncoded());

    keyFactory = KeyFactory.getInstance("DSA");

    PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);

    signature = Signature.getInstance("SHA1withDSA");

    signature.initVerify(publicKey);

    signature.update(SRC_TEST.getBytes());

    boolean bool = signature.verify(res);

    System.out.println("验证:" + bool);

    }

    Hash算法

    HmacMD5 具体需要什么直接可以通过KeyGenerator.getInstance(); 来构造这里就不重复这里需要所密的是用base64 算法对key作处理这要就能保证key值的乱码显示和存储

    private static final String HMAC_MD5 = "HmacMD5";

    public static String initMacKey() throws Exception {

    KeyGenerator keyGenerator = KeyGenerator.getInstance(HMAC_MD5);

    SecretKey secretKey = keyGenerator.generateKey();

    return Base64.getEncoder().encodeToString(secretKey.getEncoded());

    }

    public static String hashMsgCode(byte[] data, String key) throws Exception {

    SecretKey secretKey = new SecretKeySpec(Base64.getDecoder().decode(key), HMAC_MD5);

    Mac mac = Mac.getInstance(secretKey.getAlgorithm());

    mac.init(secretKey);

    return new String(Hex.encodeHex(mac.doFinal(data)));

    }

    public static void main(String[] args) throws Exception {

    String macKey = initMacKey();

    System.out.println("key:\n" + macKey);

    String msg = "测试数据";

    String msgCode = hashMsgCode(msg.getBytes(), macKey);

    System.out.println("code:\n" + msgCode);

    }

    SHA

    public static void main(String[] args) throws Exception{

    String msg = "测试SHA";

    String hashMsg = msgSafeBase(msg, "SHA-256");

    System.out.println("msg:"+msg);

    System.out.println("code:"+hashMsg);

    }

    private static final String UTF_8="UTF-8";

    public static String msgSafeBase(String msg,String algorithem) throws Exception{

    MessageDigest m = MessageDigest.getInstance(algorithem);

    m.update(msg.getBytes(UTF_8));

    byte[] s = m.digest();

    return Hex.encodeHexString(s);

    }

    展开全文
  • 一、引言这段时间在写论文,所以题目就叫做引言吧,在开始对对称加密算法真正认识之前,我们先看另外一块知识。相信我们都学过计算机中的一种位运算,叫做与或非(高中的时候就讲过,不知道的就回去补补)。下面这种...

    对数据的加密算是一个老生常谈的话题了,加密的方式很多,java也为这些加密算法提供了支持。今天就来聊聊对称加密算法的java实现方式。本文对加密算法不了解也没关系,我会从0开始讲解,保证小白也能看懂。

    一、引言

    这段时间在写论文,所以题目就叫做引言吧,在开始对对称加密算法真正认识之前,我们先看另外一块知识。相信我们都学过计算机中的一种位运算,叫做与或非(高中的时候就讲过,不知道的就回去补补)。下面这种运算叫做异或运算,是与或非运算的变形:

    0 

    从上面的结果我们可以看到,两个数相同就返回为0,不相同就是为1;从这个运算规则中我们还可以得到很多规律,其中有一条很重要的交换律,就是我们对称加密算法的核心。

    a 

    从上面我们可以看到了,通过b加密,然后再通过b解密就可以拿到源数据a了。这就是对称加密的思想核心。

    不过到这我们可以会发现一个问题,秘钥b是非常核心重要的一个数据,如果我们的b泄露了,那么我们的数据a也就被泄漏了。

    OK。到了这我们的算是稍微明白一点对称加密的意思了。下面我们就开始正式的认识一下对称加密。

    二、对称加密基础

    为了对上面的过程理解方便,我们使用一个案例来进行展示,比如说我们要对数据homework进行加密解密。

    首先是加密

    be15671c3149e57629e82d60a7196373.png

    然后是解密

    3e54ed71f4703e8d4019761c16b9287b.png

    对照这两个相反的过程,数据是一一对应的。这种方式其实叫做:一次性加密本,现在你应该明白对称加密是个啥玩意了吧。这种加密算法看起来很简单,那么在实际当中一定广泛使用吧,真实情况确实没有人用,我们来分析一下这种方式的缺点:

    (1)秘钥传输过程中很容易被截获

    (2)原文很长时,秘钥也很长

    (3)保存秘钥很困难

    (4)秘钥的正确定无法保证:也就是说秘钥错一位,基本上整个秘钥报废了。

    鉴于有这些缺点,因此出现很多其他对称加密的算法。

    三、对称加密算法

    基于对称加密机制的算法有很多,比如说DES、3DES、AES、PBE。我们一个一个先来认识一下,不会涉及到底层太多,对每一种算法的实现,我会花费专门的文章进行讲解分析。

    1、DES

    DES 是一种把 64 位明文加密成 64 位密文的对称加密算法。它的密钥长度为 64 比特,但是每 7 个二进制位会设置一个用于错误检测的位,实际上密钥长度就剩下了 56 比特。DES 只能一次性加密 64 位明文,如果明文超过了 64 位,就要进行分组加密。

    c6e64230d68a6cafc74f21361e5fbafe.png

    上面的过程是加密,解密过程反过来就能明白,这种方式有很大的缺点,不管是加密还是解密,都有很大的不安全性。一般不会使用。

    2、3DES

    这种方式就是为了避免DES的缺点,既然DES加密一次会不安全,那就多加几个步骤,这里加密解密再加密三次就叫做三重DES。DES 密钥长度为 56 位,所以 3DES 密钥长度为 56 * 3 = 168 位。

    f26297ddfc15f39eebaa8534a127b5b6.png

    注意:这里可不是对DES执行了三次加密解密的操作,而是加密-解密-加密。

    上面的流程同样是只给出了加密的过程,当然对于解密的过程也很简单,反过来解密-加密-解密。3DES 是对DES的一个升级,但是由于速度不高,因此也在淘汰。

    3、AES

    AES算是一种比较常见的加密算法了,AES为分组密码,也就是把明文分成一组一组的、长度相等、每组16个字节的数据,每次加密一组数据,直到加密完整个明文。在AES标准规范中,分组长度只能是128位。但是密钥的长度可以使用128位、192位或256位。

    这里你可能有个疑问,在文章一开始不是说了嘛。对称加密机制我们的数据明文128位,那么秘钥要一一对应,应该也是128位呀?其实AES实施的多次加密,密钥的长度不同,推荐加密轮数也不同。

    579c32ab2fe829f744f449f076c2d7b5.png

    内部细节没有给出。

    4、PBE

    PBE是一种基于口令的加密算法,其特点在于口令是由用户自己掌握的,采用随机数杂凑多重加密等方法保证数据的安全性。没有密钥的概念,密钥在其它对称加密算法中是经过算法计算得出来的,PBE算法则是使用口令替代了密钥。

    bfc3c02f1d271617277bed0cc044ff3b.png

    这就是加密的整个流程。很简单的一个流程。

    以上我们对这四种常见的对称加密算法进行一个认识和简单的介绍,下面我们就开始使用java代码来实现一波。

    四、代码实现

    在正式的代码编写之前,我们先要认识一下工具类,它是把byte转换为16进制String。也就是说把加密之后的数据转变成16进制String。

    public 

    1、DES算法实现

    public 

    2、3DES算法实现

    public 

    3、AES算法实现

    public 

    4、PBE算法实现

    public 

    OK。代码实现基本上都是套路,每一种看代码相信都能看懂。对于安全这块的知识真的是太多了,因此我也是主要学习和java相关的一些安全的知识点,如有问题还请指正。

    4d60c0dd4a7b536e1ede3f51df92b0e2.png
    展开全文
  • java EJB 加密与解密原理的一个例子更新时间:2008年01月11日 21:57:39 作者:java EJB 加密与解密原理的一个例子加密与解密原理的一个例子packagelockunlock;importJava.awt.*;importjava.awt.event.*;importjava....

    java EJB 加密与解密原理的一个例子

    更新时间:2008年01月11日 21:57:39   作者:

    java EJB 加密与解密原理的一个例子

    加密与解密原理的一个例子

    package lockunlock;

    import Java.awt.*;

    import java.awt.event.*;

    import java.Applet.*;

    import javax.Swing.*;

    import java.util.*;

    public class LockUnlock extends JApplet {

    private boolean isStandalone = false;

    //Get a parameter value

    public String getParameter(String key, String def) {

    return isStandalone ? System.getProperty(key, def) :

    (getParameter(key) != null ? getParameter(key) : def);

    }

    //Construct the applet

    public LockUnlock() {

    }

    //Initialize the applet

    public void init() {

    try {

    jbInit();

    }

    catch(Exception e) {

    e.printStackTrace();

    }

    }

    //Component initialization

    private void jbInit() throws Exception {

    contentPane = (JPanel) this.getContentPane();

    jLabel1.setText("String");

    jLabel1.setBounds(new Rectangle(35, 36, 57, 21));

    contentPane.setLayout(null);

    this.setSize(new Dimension(400, 300));

    jLabel2.setText("String length");

    jLabel2.setBounds(new Rectangle(29, 73, 69, 22));

    jTextField1.setText("");

    jTextField1.setBounds(new Rectangle(108, 40, 166, 17));

    jTextField2.setText("");

    jTextField2.setBounds(new Rectangle(107, 72, 56, 21));

    jButton1.setBounds(new Rectangle(30, 236, 137, 27));

    jButton1.setText("Exercise 3");

    jButton1.addActionListener(new LockUnlock_jButton1_actionAdapter(this));

    jButton2.setBounds(new Rectangle(218, 237, 131, 27));

    jButton2.setText("Exercise 4");

    jButton2.addActionListener(new LockUnlock_jButton2_actionAdapter(this));

    jTextField3.setText("");

    jTextField3.setBounds(new Rectangle(106, 105, 58, 21));

    jLabel3.setText("MoShu");

    jLabel3.setBounds(new Rectangle(36, 106, 86, 18));

    contentPane.add(jLabel1, null);

    contentPane.add(jButton2, null);

    contentPane.add(jButton1, null);

    contentPane.add(jLabel3, null);

    contentPane.add(jTextField2, null);

    contentPane.add(jLabel2, null);

    contentPane.add(jTextField3, null);

    contentPane.add(jTextField1, null);

    }

    //Get Applet information

    public String getAppletInfo() {

    return "Applet Information";

    }

    //Get parameter info

    public String[][] getParameterInfo() {

    return null;

    }

    //Main method

    public static void main(String[] args) {

    LockUnlock applet = new LockUnlock();

    applet.isStandalone = true;

    JFrame frame = new JFrame();

    //EXIT_ON_CLOSE == 3

    frame.setDefaultCloseOperation(3);

    frame.setTitle("Applet Frame");

    frame.getContentPane().add(applet, BorderLayout.CENTER);

    applet.init();

    applet.start();

    frame.setSize(400,320);

    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();

    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);

    frame.setVisible(true);

    }

    //static initializer for setting look & feel

    static {

    try {

    //UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

    //UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());

    }

    catch(Exception e) {

    }

    }

    //Declare DataMember

    int index;

    //-----------------------------------------------------

    JPanel contentPane;

    JLabel jLabel1 = new JLabel();

    JLabel jLabel2 = new JLabel();

    JTextField jTextField2 = new JTextField();

    JTextField jTextField1 = new JTextField();

    JButton jButton1 = new JButton();

    JButton jButton2 = new JButton();

    JTextField jTextField3 = new JTextField();

    JLabel jLabel3 = new JLabel();

    //----------------------N!------------------------------

    public int function(int N){

    if(N==1)

    return 1;

    else{

    return N*function(N-1);

    /*不是RETURN function(N-1);

    而是 N*function(N-1);*/

    }

    }

    //-----------用递归法求一个串的全排列-----------------------

    public void Arrange(String prefix,String suffix,int[] Array){

    String newPrefix,newSuffix;

    int numOfChars =suffix.length();

    if(numOfChars==1){

    Array[index]=Integer.parseInt(prefix+suffix);

    index++;

    }

    else{

    for(int i=1; i<=numOfChars;i++){

    newSuffix=suffix.substring(1,numOfChars);

    newPrefix=prefix+suffix.charAt(0);

    Arrange(newPrefix,newSuffix,Array);

    suffix=newSuffix+suffix.charAt(0);

    }

    }

    }

    //----------Arrange From the Min to the Max------------------

    /*public void RankForArrange(int[] Array){

    int bottom=Array.length-1 ;

    int temp;

    for(int i=bottom;i>0;i--){

    for(int j=0;j

    if(Array[j]>Array[j+1]){

    temp =Array[j];

    Array[j] =Array[j+1];

    Array[j+1]=temp;

    }

    }

    }

    }

    */

    //-------------------Find the aim number----------------------

    public int FindAim(int aim,int[] Array){

    boolean isFound=false;

    int location=0;

    int length=Array.length ;

    for(int i=0;i

    if(Array[i]==aim){

    location=i;

    isFound =true;

    }

    }

    if(isFound)

    return location;

    else

    System.out.println("Not Found");

    return location;

    /*在if里return 不行吗?*/

    }

    //------------------Creat String-------------------------------

    public String CreatString(int length){

    StringBuffer BufString=new StringBuffer();

    for(int i=1;i<=length;i++){

    BufString.append(i) ;

    }

    return BufString.toString();

    }

    //-----------OutPut Result--------------------

    public void OutPutResult1(){

    index = 0; //clear to 0

    String AimString, prefix;

    AimString = jTextField1.getText();

    int Length = AimString.length();

    String strLength = String.valueOf(Length);

    int Aim = Integer.parseInt(AimString);

    /* 方法.parseInt才是转换为int类型

    而不是.getInteger*/

    int[] EachArrange = new int[this.function(Length)];

    jTextField2.setText(strLength);

    prefix = ""; //Make an empty String

    if (AimString.length() > 2 &&

    AimString.length() 

    Arrange(prefix, AimString, EachArrange);

    //RankForArrange(EachArrange);

    Arrays.sort(EachArrange);

    String result = String.valueOf(FindAim(Aim, EachArrange));

    jTextField3.setText(result);

    }

    else {

    System.out.println("Your String is too short");

    }

    }

    //----------Out put result 2---------------------

    public void OutPutRestlt2(){

    index=0;//Let index come back to 0

    String strLength, strMoShu,

    AimString, prefix,suffix;

    int Length, MoShu,limit;

    strLength = jTextField2.getText();

    strMoShu = jTextField3.getText();

    Length = Integer.parseInt(strLength);

    MoShu = Integer.parseInt(strMoShu);

    limit = function(Length);

    int[] EachArrange = new int[this.function(Length)];

    if (Length > 2&&Length<9&&

    strLength!=""&&strMoShu!=""

    &&MoShu

    prefix = "";

    suffix =CreatString(Length);

    Arrange(prefix, suffix, EachArrange);

    Arrays.sort(EachArrange);

    String strResult=String.valueOf(EachArrange[MoShu]);

    jTextField1.setText(strResult);

    }

    else

    System.out.println("Input Ouf MoShu, Try again") ;

    }

    void jButton1_actionPerformed(ActionEvent e) {

    this.OutPutResult1();

    }

    void jButton2_actionPerformed(ActionEvent e) {

    this.OutPutRestlt2();

    }

    //-----------------------------------------------------------

    }

    class LockUnlock_jButton1_actionAdapter implements java.awt.event.ActionListener {

    LockUnlock adaptee;

    LockUnlock_jButton1_actionAdapter(LockUnlock adaptee) {

    this.adaptee = adaptee;

    }

    public void actionPerformed(ActionEvent e) {

    adaptee.jButton1_actionPerformed(e);

    }

    }

    class LockUnlock_jButton2_actionAdapter implements java.awt.event.ActionListener {

    LockUnlock adaptee;

    LockUnlock_jButton2_actionAdapter(LockUnlock adaptee) {

    this.adaptee = adaptee;

    }

    public void actionPerformed(ActionEvent e) {

    adaptee.jButton2_actionPerformed(e);

    }

    }

    相关文章

    1a1b05c64693fbf380aa1344a7812747.png

    这篇文章主要介绍了PHP答题类应用接口,以实例形式详细分析了答题类程序的实现思路与相关技巧,并备有较为详尽的注释说明,便于理解,需要的朋友可以参考下2015-02-02

    4f55910a645b073bc4fc65dc10dc14bd.png

    这篇文章主要介绍了PHP实现获取url地址中顶级域名的方法,结合实例形式分析了php使用parse_url()针对URL域名解析相关操作技巧,需要的朋友可以参考下2019-06-06

    0ea3c7666119d5615e582f823fb3fad6.png

    PHP 创建文件(文件夹)以及目录操作代码,需要的朋友可以参考下。2010-03-03

    4f96a78db829b1556ff16de21e013c7a.png

    这篇文章主要介绍了PHP实现对数组分页处理,结合实例形式分析了php封装的数组分页类定义与使用技巧,需要的朋友可以参考下2017-02-02

    8cc1031babc6aff2319f1c6af8544aa0.png

    php学习之数据类型之间的转换代码,主要解决php中一些数据类型之间的相互转换。2011-05-05

    0c932a99bb7b6f23c937db507070cc7b.png

    在本篇文章里小编给大家分享了关于PHP判断函数是否被定义的相关方法和知识点,需要的朋友们参考下。2019-06-06

    cca732bf65a93ed2ec0ac80c638460fe.png

    这篇文章主要介绍了在html文件中也可以执行php语句的方法,需要的朋友可以参考下2015-04-04

    2d9f31f2af7b675a3d153d2b7f1035a7.png

    这篇文章主要介绍了PHP利用APC模块实现大文件上传进度条的方法,并分享了相关配置说明,感兴趣的朋友可以学习借鉴。2015-10-10

    b452cee8ec5cd9e58ab98eba17281e59.png

    PHP开发中需要注意的问题,这样要吧提高PHP编程效率2013-11-11

    f4838ec7e2d4da28e0b57d4e852dadd4.png

    这篇文章主要介绍了PHP实现的各种进制相互转换功能小工具,涉及php常见的二进制、八进制、十六进制等相互转换操作实现技巧,需要的朋友可以参考下2018-03-03

    最新评论

    展开全文
  • java的aes加密成多少位数关注:170答案:3mip版解决时间 2021-02-06 07:08提问者彼岸独舞2021-02-05 21:50java的aes加密成多少位数最佳答案二级知识专家亲亲兔耳朵2021-02-05 22:51深圳远标帮你:1.默认 Java 中仅支持...

    java的aes加密成多少位数

    关注:170  答案:3  mip版

    解决时间 2021-02-06 07:08

    e6cb1a03ad541b3098697807b7bf1798.png

    提问者彼岸独舞

    2021-02-05 21:50

    java的aes加密成多少位数

    最佳答案

    e6cb1a03ad541b3098697807b7bf1798.png

    二级知识专家亲亲兔耳朵

    2021-02-05 22:51

    深圳远标帮你:

    1.默认 Java 中仅支持 128 位密钥,当使用 256 位密钥的时候,会报告密钥长度错误

    Invalid AES key length

    你需要下载一个支持更长密钥的包。这个包叫做 Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 6

    看一下你的 JRE 环境,将 JRE 环境中 lib\lib\security 中的同名包替换掉。

    2. Base64 问题

    // 编码

    String asB64 = new Base64().encodeToString("some string".getBytes("utf-8"));

    System.out.println(asB64); // 输出为: c29tZSBzdHJpbmc=

    解码

    // 解码

    byte[] asBytes = new Base64().getDecoder().decode("c29tZSBzdHJpbmc=");

    System.out.println(new String(asBytes, "utf-8")); // 输出为: some string

    如果你已经使用 Java 8,那么就不需要再选用第三方的实现了,在 java.util 包中已经包含了 Base64 的处理。

    编码的方式

    // 编码

    String asB64 = Base64.getEncoder().encodeToString("some string".getBytes("utf-8"));

    System.out.println(asB64); // 输出为: c29tZSBzdHJpbmc=

    解码处理

    // 解码

    byte[] asBytes = Base64.getDecoder().decode("c29tZSBzdHJpbmc=");

    System.out.println(new String(asBytes, "utf-8")); // 输出为: some string

    3. 关于 PKCS5 和 PKCS7 填充问题

    PKCS #7 填充字符串由一个字节序列组成,每个字节填充该填充字节序列的长度。

    假定块长度为 8,数据长度为 9,

    数据: FF FF FF FF FF FF FF FF FF

    PKCS7 填充: FF FF FF FF FF FF FF FF FF 07 07 07 07 07 07 07

    简单地说, PKCS5, PKCS7和SSL3, 以及CMS(Cryptographic Message Syntax)

    有如下相同的特点:

    1)填充的字节都是一个相同的字节

    2)该字节的值,就是要填充的字节的个数

    如果要填充8个字节,那么填充的字节的值就是0×8;

    要填充7个字节,那么填入的值就是0×7;

    如果只填充1个字节,那么填入的值就是0×1;

    这种填充方法也叫PKCS5, 恰好8个字节时还要补8个字节的0×08

    正是这种即使恰好是8个字节也需要再补充字节的规定,可以让解密的数据很确定无误的移除多余的字节。

    比如, Java中

    Cipher.getInstance(“AES/CBC/PKCS5Padding”)

    这个加密模式

    跟C#中的

    RijndaelManaged cipher = new RijndaelManaged();

    cipher.KeySize = 128;

    cipher.BlockSize = 128;

    cipher.Mode = CipherMode.CBC;

    cipher.Padding = PaddingMode.PKCS7;

    的加密模式是一样的

    因为AES并没有64位的块, 如果采用PKCS5, 那么实质上就是采用PKCS7

    全部回答

    e6cb1a03ad541b3098697807b7bf1798.png

    1楼失心瘋

    2021-02-06 00:42

    这篇文章有详细的AES算法的使用讲解,希望可以帮助到你,https://blog.csdn.net/xingkong_hdc/article/details/79413462

    e6cb1a03ad541b3098697807b7bf1798.png

    2楼招人烦°惹人厌

    2021-02-06 00:03

    使用aes加密时,当密钥大于128时,代码会抛出java.security.invalidkeyexception: illegal key size or default parameters

    illegal key size or default parameters是指密钥长度是受限制的,java运行时环境读到的是受限的policy文件。文件位于${java_home}/jre/lib/security

    这种限制是因为美国对软件出口的控制。

    解决办法:

    去掉这种限制需要下载java cryptography extension (jce) unlimited strength jurisdiction policy files.网址如下。

    下载包的readme.txt 有安装说明。就是替换${java_home}/jre/lib/security/ 下面的local_policy.jar和us_export_policy.jar

    jdk 5: http://www.oracle.com/technetwork/java/javasebusiness/downloads/java-archive-downloads-java-plat-419418.html#jce_policy-1.5.0-oth-jpr

    我要举报

    如以上问答内容为低俗/色情/暴力/不良/侵权的信息,可以点下面链接进行举报,我们会做出相应处理,感谢你的支持!

    →点此我要举报以上信息!←

    推荐资讯

    大家都在看

    展开全文
  • Java加密

    2016-01-07 14:48:00
    Java加密  /** * .功能: md5加密,如果加密失败,返回null 时间: 2015-7-9上午11:35:25 作者: lyf */ public static final String md5(String str) { try { Message...
  • 如何用Java实现文件的加密与解密发布时间:2020-06-01 15:39:43来源:亿速云阅读:220作者:鸽子今天带来的java小项目实现文件加密解密,核心代码已展示出来界面展示:部分代码展示:package wt.diy.encryption.gui;...
  • java 对称加密算法实现详解发布时间:2020-08-24 14:26:05来源:脚本之家阅读:99作者:小破孩123前言对于信息的加密方式多种多样,之前为大家介绍了一种自己设计的加密方式,有兴趣的朋友可以欣赏一下,欢迎给予...
  • @文件加密压缩在现如今已经可以实现大部分功能的互联网需求中,安全成为了需要的非必需品,工作需求中会遇到对导出的 excel 报表 做加密压缩的问题,今天有时间总结一下,我这里简单列举功能代码,连带其它代码文末...
  • 一 非对称加密非对称加密和解密花费的时间长非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(privatekey),一般使用公钥进行加密,使用私钥进行解密。常见的非对称加密算法有:RSA、ECC(移动设备用)、...
  • [更新2016-06-08:根据...][更新时间2016-08-05:Java 8u101已经发布,确实包括IdenTrust CA:release notes]Does Java support Let’s Encrypt certif...
  • 本示例演示使用DES算法加密对象。加密对象后,我们将其存储在文件中,该文件将在下一个示例中解密,该...importjava.io.*;importjavax.crypto.Cipher;importjavax.crypto.KeyGenerator;importjavax.crypto.SealedObj...
  • 这是当前用于加密和解密过程的代码,它的工作方式也是如此,除了加密和解密的时间很长.import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;...
  • Java加密算法

    2018-11-03 23:27:00
    因为就密钥而言,如果加密的密钥越大,则其计算的复杂度越高,所需要的时间越长,而如果使用的密钥较小,则很容易破解,所以密钥的大小需根据业务需求去选择。 通常,加密的算法有:DES、3DES、Blowfis...
  • import javax.crypto.*;import javax.crypto.spec....import java.security.NoSuchAlgorithmException;import java.security.InvalidKeyException;import java.security.SecureRandom;import java.security....
  • public classutil {/*** 传入名文和公钥钥对数据进行RSA解密* 生成时间:2014年5月2日 下午2:38:13* 返回值:String* @paramsrc* @parampubkey* @return*/public staticString rsaEncoding(String src,PublicKey ...
  • 凯撒加密Java

    2013-06-24 10:26:02
    java凯撒加密代码,并可以统计加密时间,,以及加密位移
  • 因为项目有用到,所以花了点时间对rsa加密做了一点点了解,发现,不管是java 还是 C# 都对 rsa 的标准加密进行了实现, 是 对于标准是实现,不能互通就讲不过去了. 今天特意写了一段java 代码试了一下,发现是完全可以的....
  • 前段时间由于项目需要,使用java生成PDF文件,然后将文件压缩成ZIP格式,同时对压缩文件进行加密,先将代码及jar包上传供大家参考,并希望大家共同完善和学习。 java生成PDF,java加密压缩文件并,java生成PDF后压缩...
  • 这个是java做成的安全处理的包 可以时间字符串的签名 加密解密 和 文件的签名加密解密 里面有API和几个例子 用起来很方便 有问题还可以和作者联系 里面有他的EMAIL
  • asp字符串加密解密函数更新时间:2007年06月30日 00:00:00 作者:A_Key=split("96,44,63,80",",")'定义密钥'*********加密的过程*********FunctionEnCrypt(m)DimstrChar,iKeyChar,iStringChar,Ik=0forI=1toLen(m)...
  • 解决JAVA非对称加密不同系统加密结果不一致的问题发布时间:2020-10-24 11:51:15来源:脚本之家阅读:66作者:烈军最近在做一个项目,需要用到非对称加密,但是出现一个很诡异的情况,本地开发环境是Windows环境,...
  • 这里我们可以利用jquery的一个加密插件jcryption来处理,可以参考现在版本是3.0但是没有java端的实现,下次有时间再研究。现在这个用的是1.1的版本这个可以在不过他的服务端有个缺陷我修改了。接来大致介绍如下:1....
  • java 加密技术

    2016-03-01 13:47:27
    Java加密(单向)    为了防止我的移动硬盘再次被格式化。我还是将自己认为重要的东西写到博客里边吧。同时,如果我哪个地方写的不对,还请广大网友指正。  加密技术分为三种(单向,对称,非对称)  单向:...
  • 一、引言这段时间在写论文,所以题目就叫做引言吧,在开始对对称加密算法真正认识之前,我们先看另外一块知识。相信我们都学过计算机中的一种位运算,叫做与或非(高中的时候就讲过,不知道的就回去补补)。下面这种.....
  • Android与Java服务端加密解密

    千次阅读 2015-08-10 15:28:21
    本篇博客是使用Android端与...在Android端做数据加密操作以前在做毕业设计的时候就想把这个功能加进去,奈何时间有限,知识有限再加上这个需求并没有那么迫切,时间一长就没有继续纠缠下去了。现如今,项目中要求加上
  • 由于没时间整理,直接贴出代码,不理解的请留言,谢谢。 package com.rocky.fintech.boss.util; import org.apache.commons.codec.binary.Hex; import java.security.MessageDigest; import java.util....
  • java 加密

    2007-11-28 19:49:00
    /** *//** * @开发人 毛卓强 * @开发时间 2007-11-28 17:21:19 * @开发公司 长广信 */import java.security.*; import javax.crypto.*; public class jiami ...{ private static Stri...
  • 这是当前用于加密和解密过程的代码,它的工作方式也是如此,除了加密和解密的时间很长.import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;...
  • Java加密算法

    2019-03-30 16:02:00
    密码的常用术语:  1.密码体制:由明文空间、密文空间、密钥空间、加密算法和解密算法5部分组成。  2.密码协议:也称为安全协议,是...  3....即系统的安全取决于密钥,对密钥保密,对算法公开。... 按照时间可以分...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,298
精华内容 519
关键字:

java时间加密

java 订阅