用java程序进行sha1加密，怎么弄

public class Sha1 {  

    / 

      SHA1 安全加密算法 

      @param maps 参数key-value map集合 

      @return 

      @throws DigestException  

     /  

    public static String SHA1(Map<String,Object> maps) throws DigestException {  

        //获取信息摘要 - 参数字典排序后字符串  

        String decrypt = getOrderByLexicographic(maps);  

        try {  

            //指定sha1算法  

            MessageDigest digest = MessageDigestgetInstance("SHA-1");  

            digestupdate(decryptgetBytes());  

            //获取字节数组  

            byte messageDigest[] = digestdigest();  

            // Create Hex String  

            StringBuffer hexString = new StringBuffer();  

            // 字节数组转换为 十六进制 数  

            for (int i = 0; i < messageDigestlength; i++) {  

                String shaHex = IntegertoHexString(messageDigest[i] & 0xFF);  

                if (shaHexlength() < 2) {  

                    hexStringappend(0);  

                }  

                hexStringappend(shaHex);  

            }  

            return hexStringtoString()toUpperCase();  

        } catch (NoSuchAlgorithmException e) {  

            eprintStackTrace();  

            throw new DigestException("签名错误！");  

        }  

    }  

    / 

      获取参数的字典排序 

      @param maps 参数key-value map集合 

      @return String 排序后的字符串 

     /  

    private static String getOrderByLexicographic(Map<String,Object> maps){  

        return splitParams(lexicographicOrder(getParamsName(maps)),maps);  

    }  

    / 

      获取参数名称 key 

      @param maps 参数key-value map集合 

      @return 

     /  

    private static List<String> getParamsName(Map<String,Object> maps){  

        List<String> paramNames = new ArrayList<String>();  

        for(MapEntry<String,Object> entry : mapsentrySet()){  

            paramNamesadd(entrygetKey());  

        }  

        return paramNames;  

    }  

    / 

      参数名称按字典排序 

      @param paramNames 参数名称List集合 

      @return 排序后的参数名称List集合 

     /  

    private static List<String> lexicographicOrder(List<String> paramNames){  

        Collectionssort(paramNames);  

        return paramNames;  

    }  

    / 

      拼接排序好的参数名称和参数值 

      @param paramNames 排序后的参数名称集合 

      @param maps 参数key-value map集合 

      @return String 拼接后的字符串 

     /  

    private static String splitParams(List<String> paramNames,Map<String,Object> maps){  

        StringBuilder paramStr = new StringBuilder();  

        for(String paramName : paramNames){  

            paramStrappend(paramName);  

            for(MapEntry<String,Object> entry : mapsentrySet()){  

                if(paramNameequals(entrygetKey())){  

                    paramStrappend(StringvalueOf(entrygetValue()));  

                }  

            }  

        }  

        return paramStrtoString();  

    }

import javautilHashMap;

import javautilMap;

public class NewJFrame extends javaxswingJFrame {

public static Map<Character,Integer> charmap = new HashMap<Character,Integer>();

public static char stringmap[] = new char[]{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o',

'p','q' ,'r','s','t','u','v','w','x','y','z'

};

static{

charmapput('a', 1);

charmapput('b', 2);

charmapput('c', 3);

charmapput('d', 4);

charmapput('e', 5);

charmapput('f', 6);

charmapput('g', 7);

charmapput('h', 8);

charmapput('i', 9);

charmapput('j', 10);

charmapput('k', 11);

charmapput('l', 12);

charmapput('m', 13);

charmapput('n', 14);

charmapput('o', 15);

charmapput('p', 16);

charmapput('q', 17);

charmapput('r', 18);

charmapput('s', 19);

charmapput('t', 20);

charmapput('u', 21);

charmapput('v', 22);

charmapput('w', 23);

charmapput('x', 24);

charmapput('y', 25);

charmapput('z', 26);

charmapput('A', 1);

charmapput('B', 2);

charmapput('C', 3);

charmapput('D', 4);

charmapput('E', 5);

charmapput('F', 6);

charmapput('G', 7);

charmapput('H', 8);

charmapput('I', 9);

charmapput('J', 10);

charmapput('K', 11);

charmapput('L', 12);

charmapput('M', 13);

charmapput('N', 14);

charmapput('O', 15);

charmapput('P', 16);

charmapput('Q', 17);

charmapput('R', 18);

charmapput('S', 19);

charmapput('T', 20);

charmapput('U', 21);

charmapput('V', 22);

charmapput('W', 23);

charmapput('X', 24);

charmapput('Y', 25);

charmapput('Z', 26);

}

public NewJFrame() {

initComponents();

}

private char change(char c) {

int i = charmapget(c);

int k = 2;

int j;

j=(i+k) % 26 ;

return stringmap[--j];

}

// <editor-fold defaultstate="collapsed" desc="Generated Code">

private void initComponents() {

jPanel1 = new javaxswingJPanel();

ba = new javaxswingJButton();

ta = new javaxswingJTextField();

tb = new javaxswingJTextField();

setDefaultCloseOperation(javaxswingWindowConstantsEXIT_ON_CLOSE);

basetText("转换");

baaddActionListener(new javaawteventActionListener() {

public void actionPerformed(javaawteventActionEvent evt) {

baActionPerformed(evt);

}

});

tbsetEnabled(false);

javaxswingGroupLayout jPanel1Layout = new javaxswingGroupLayout(jPanel1);

jPanel1setLayout(jPanel1Layout);

jPanel1LayoutsetHorizontalGroup(

jPanel1LayoutcreateParallelGroup(javaxswingGroupLayoutAlignmentLEADING)

addGroup(jPanel1LayoutcreateSequentialGroup()

addGroup(jPanel1LayoutcreateParallelGroup(javaxswingGroupLayoutAlignmentLEADING)

addGroup(jPanel1LayoutcreateSequentialGroup()

addGap(66, 66, 66)

addGroup(jPanel1LayoutcreateParallelGroup(javaxswingGroupLayoutAlignmentLEADING, false)

addComponent(tb)

addComponent(ta, javaxswingGroupLayoutDEFAULT_SIZE, 316, ShortMAX_VALUE)))

addGroup(jPanel1LayoutcreateSequentialGroup()

addGap(147, 147, 147)

addComponent(ba, javaxswingGroupLayoutPREFERRED_SIZE, 79, javaxswingGroupLayoutPREFERRED_SIZE)))

addContainerGap(59, ShortMAX_VALUE))

);

jPanel1LayoutsetVerticalGroup(

jPanel1LayoutcreateParallelGroup(javaxswingGroupLayoutAlignmentLEADING)

addGroup(javaxswingGroupLayoutAlignmentTRAILING, jPanel1LayoutcreateSequentialGroup()

addContainerGap()

addComponent(ta, javaxswingGroupLayoutPREFERRED_SIZE, 38, javaxswingGroupLayoutPREFERRED_SIZE)

addPreferredGap(javaxswingLayoutStyleComponentPlacementUNRELATED)

addComponent(tb, javaxswingGroupLayoutDEFAULT_SIZE, 38, ShortMAX_VALUE)

addGap(18, 18, 18)

addComponent(ba)

addContainerGap())

);

javaxswingGroupLayout layout = new javaxswingGroupLayout(getContentPane());

getContentPane()setLayout(layout);

layoutsetHorizontalGroup(

layoutcreateParallelGroup(javaxswingGroupLayoutAlignmentLEADING)

addComponent(jPanel1, javaxswingGroupLayoutDEFAULT_SIZE, javaxswingGroupLayoutDEFAULT_SIZE, ShortMAX_VALUE)

);

layoutsetVerticalGroup(

layoutcreateParallelGroup(javaxswingGroupLayoutAlignmentLEADING)

addComponent(jPanel1, javaxswingGroupLayoutDEFAULT_SIZE, javaxswingGroupLayoutDEFAULT_SIZE, ShortMAX_VALUE)

);

pack();

}// </editor-fold>

private void baActionPerformed(javaawteventActionEvent evt) {

String aa = tagetText();

char bb[] = aatoCharArray();

char cc[] = new char[bblength];

for(int i = 0; i < bblength;i++){

cc[i] = change(bb[i]);

}

tbsetText(StringvalueOf(cc));

}

public static void main(String args[]) {

javaawtEventQueueinvokeLater(new Runnable() {

public void run() {

new NewJFrame()setVisible(true);

}

});

}

// Variables declaration - do not modify

private javaxswingJButton ba;

private javaxswingJPanel jPanel1;

private javaxswingJTextField ta;

private javaxswingJTextField tb;

// End of variables declaration

}

private void initComponents() 这个方法不用太在意，只是个生成界面的方法而已

看不懂这个方法也没关系

最简单的，用异或运算。

你也可以自己写个加密方法啊。

比如说：利用unicode字符加密啊。假设一个数字a它的unicode值是1234，你自己设计个函数，比如说y=2x^3+3，得到一个新的unicode字符，然后把这个unicode字符转换为字母，这个字母可能是汉字，但更可能是外国符文，反正一般人不会认出来的。你解密的时候，倒推一下就行了。

一般只有加密码过程，没有解密。

用户登陆时，把他输入的密码经过加密

再拿去与数据库里面的密码比较就可以了。

修改密码也是一样的原理，输入的原密码加密后与数据库密码比较，符合的话再将新密码加密后存入数据库覆盖原密码

现在流行的MD5加密算法 网上有很多JAVA的MD5算法

Java有相关的实现类：具体原理如下

对于任意长度的明文，AES首先对其进行分组，每组的长度为128位。分组之后将分别对每个128位的明文分组进行加密。

对于每个128位长度的明文分组的加密过程如下：

（1）将128位AES明文分组放入状态矩阵中。

（2）AddRoundKey变换：对状态矩阵进行AddRoundKey变换，与膨胀后的密钥进行异或 *** 作（密钥膨胀将在实验原理七中详细讨论）。

（3）10轮循环：AES对状态矩阵进行了10轮类似的子加密过程。前9轮子加密过程中，每一轮子加密过程包括4种不同的变换，而最后一轮只有3种变换，前9轮的子加密步骤如下：

● SubBytes变换：SubBytes变换是一个对状态矩阵非线性的变换；

● ShiftRows变换：ShiftRows变换对状态矩阵的行进行循环移位；

● MixColumns变换：MixColumns变换对状态矩阵的列进行变换；

● AddRoundKey变换：AddRoundKey变换对状态矩阵和膨胀后的密钥进行异或 *** 作。

最后一轮的子加密步骤如下：

● SubBytes变换：SubBytes变换是一个对状态矩阵非线性的变换；

● ShiftRows变换：ShiftRows变换对状态矩阵的行进行循环移位；

● AddRoundKey变换：AddRoundKey变换对状态矩阵和膨胀后的密钥进行异或 *** 作；

（4）经过10轮循环的状态矩阵中的内容就是加密后的密文。

AES的加密算法的伪代码如下。

在AES算法中，AddRoundKey变换需要使用膨胀后的密钥，原始的128位密钥经过膨胀会产生44个字（每个字为32位）的膨胀后的密钥，这44个字的膨胀后的密钥供11次AddRoundKey变换使用，一次AddRoundKey使用4个字（128位）的膨胀后的密钥。

三．AES的分组过程

对于任意长度的明文，AES首先对其进行分组，分组的方法与DES相同，即对长度不足的明文分组后面补充0即可，只是每一组的长度为128位。

AES的密钥长度有128比特，192比特和256比特三种标准，其他长度的密钥并没有列入到AES联邦标准中，在下面的介绍中，我们将以128位密钥为例。

四．状态矩阵

状态矩阵是一个4行、4列的字节矩阵，所谓字节矩阵就是指矩阵中的每个元素都是一个1字节长度的数据。我们将状态矩阵记为State，State中的元素记为Sij，表示状态矩阵中第i行第j列的元素。128比特的明文分组按字节分成16块，第一块记为“块0”，第二块记为“块1”，依此类推，最后一块记为“块15”，然后将这16块明文数据放入到状态矩阵中，将这16块明文数据放入到状态矩阵中的方法如图2-2-1所示。

块0

块4

块8

块12

块1

块5

块9

块13

块2

块6

块10

块14

块3

块7

块11

块15

图2-2-1 将明文块放入状态矩阵中

五．AddRoundKey变换

状态矩阵生成以后，首先要进行AddRoundKey变换，AddRoundKey变换将状态矩阵与膨胀后的密钥进行按位异或运算，如下所示。

其中，c表示列数，数组W为膨胀后的密钥，round为加密轮数，Nb为状态矩阵的列数。

它的过程如图2-2-2所示。

图2-2-2 AES算法AddRoundKey变换

六．10轮循环

经过AddRoundKey的状态矩阵要继续进行10轮类似的子加密过程。前9轮子加密过程中，每一轮要经过4种不同的变换，即SubBytes变换、ShiftRows变换、MixColumns变换和AddRoundKey变换，而最后一轮只有3种变换，即SubBytes变换、ShiftRows变换和AddRoundKey变换。AddRoundKey变换已经讨论过，下面分别讨论余下的三种变换。

1．SubBytes变换

SubBytes是一个独立作用于状态字节的非线性变换，它由以下两个步骤组成：

（1）在GF（28）域，求乘法的逆运算，即对于α∈GF（28）求β∈GF（28），使αβ =βα = 1mod（x8 + x4 + x3 + x + 1）。

（2）在GF（28）域做变换，变换使用矩阵乘法，如下所示：

由于所有的运算都在GF（28）域上进行，所以最后的结果都在GF（28）上。若g∈GF（28）是GF（28）的本原元素，则对于α∈GF（28），α≠0，则存在

β ∈ GF（28），使得：

β = gαmod（x8 + x4 + x3 + x + 1）

由于g255 = 1mod（x8 + x4 + x3 + x + 1）

所以g255-α = β-1mod（x8 + x4 + x3 + x + 1）

根据SubBytes变换算法，可以得出SubBytes的置换表，如表2-2-1所示，这个表也叫做AES的S盒。该表的使用方法如下：状态矩阵中每个元素都要经过该表替换，每个元素为8比特，前4比特决定了行号，后4比特决定了列号，例如求SubBytes(0C)查表的0行C列得FE。

表2-2-1 AES的SubBytes置换表

它的变换过程如图2-2-3所示。

图2-2-3 SubBytes变换

AES加密过程需要用到一些数学基础，其中包括GF(2)域上的多项式、GF（28）域上的多项式的计算和矩阵乘法运算等，有兴趣的同学请参考相关的数学书籍。

2．ShiftRows变换

ShiftRows变换比较简单，状态矩阵的第1行不发生改变，第2行循环左移1字节，第3行循环左移2字节，第4行循环左移3字节。ShiftRows变换的过程如图2-2-4所示。

图2-2-4 AES的ShiftRows变换

3．MixColumns变换

在MixColumns变换中，状态矩阵的列看作是域GF（28）的多项式，模(x4＋1)乘以c（x）的结果：

c(x)＝(03)x3＋(01)x2+(01)x+(02)

这里(03)为十六进制表示，依此类推。c(x)与x4＋1互质，故存在逆：

d(x)=(0B)x3＋(0D)x2＋(0G)x＋(0E)使c(x)•d(x) = (D1)mod(x4＋1)。

设有：

它的过程如图2-2-5所示。

图2-2-5 AES算法MixColumns变换

七．密钥膨胀

在AES算法中，AddRoundKey变换需要使用膨胀后的密钥，膨胀后的密钥记为子密钥，原始的128位密钥经过膨胀会产生44个字（每个字为32位）的子密钥，这44个字的子密钥供11次AddRoundKey变换使用，一次AddRoundKey使用4个字（128位）的膨胀后的密钥。

密钥膨胀算法是以字为基础的（一个字由4个字节组成，即32比特）。128比特的原始密钥经过膨胀后将产生44个字的子密钥，我们将这44个密钥保存在一个字数组中，记为W[44]。128比特的原始密钥分成16份，存放在一个字节的数组：Key[0]，Key[1]……Key[15]中。

在密钥膨胀算法中，Rcon是一个10个字的数组，在数组中保存着算法定义的常数，分别为：

Rcon[0] = 0x01000000

Rcon[1] = 0x02000000

Rcon[2] = 0x04000000

Rcon[3] = 0x08000000

Rcon[4] = 0x10000000

Rcon[5] = 0x20000000

Rcon[6] = 0x40000000

Rcon[7] = 0x80000000

Rcon[8] = 0x1b000000

Rcon[9] = 0x36000000

另外，在密钥膨胀中包括其他两个 *** 作RotWord和SubWord，下面对这两个 *** 作做说明：

RotWord( B0,B1,B2,B3 )对4个字节B0,B1,B2,B3进行循环移位，即

RotWord( B0,B1,B2,B3 ) = ( B1,B2,B3,B0 )

SubWord( B0,B1,B2,B3 )对4个字节B0,B1,B2,B3使用AES的S盒，即

SubWord( B0,B1,B2,B3 ) = ( B’0,B’1,B’2,B’3 )

其中，B’i = SubBytes（Bi），i = 0,1,2,3。

密钥膨胀的算法如下：

八．解密过程

AES的加密和解密过程并不相同，首先密文按128位分组，分组方法和加密时的分组方法相同，然后进行轮变换。

AES的解密过程可以看成是加密过程的逆过程，它也由10轮循环组成，每一轮循环包括四个变换分别为InvShiftRows变换、InvSubBytes变换、InvMixColumns变换和AddRoundKey变换；

这个过程可以描述为如下代码片段所示：

九．InvShiftRows变换

InvShiftRows变换是ShiftRows变换的逆过程，十分简单，指定InvShiftRows的变换如下。

Sr,(c+shift(r,Nb))modNb= Sr,c for 0 < r< 4 and 0 ≤ c < Nb

图2-2-6演示了这个过程。

图2-2-6 AES算法InvShiftRows变换

十．InvSubBytes变换

InvSubBytes变换是SubBytes变换的逆变换，利用AES的S盒的逆作字节置换，表2-2-2为InvSubBytes变换的置换表。

表2-2-2 InvSubBytes置换表

十一．InvMixColumns变换

InvMixColumns变换与MixColumns变换类似，每列乘以d(x)

d(x) = (OB)x3 + (0D)x2 + (0G)x + (0E)

下列等式成立：

( (03)x3 + (01)x2 + (01)x + (02) )⊙d(x) = (01)

上面的内容可以描述为以下的矩阵乘法：

十二．AddRoundKey变换

AES解密过程的AddRoundKey变换与加密过程中的AddRoundKey变换一样，都是按位与子密钥做异或 *** 作。解密过程的密钥膨胀算法也与加密的密钥膨胀算法相同。最后状态矩阵中的数据就是明文。

以上就是关于用java程序进行sha1加密，怎么弄全部的内容，包括:用java程序进行sha1加密，怎么弄、用java编写一个数据加密的程序、Java编程如何给数字加密等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！