//:source/SHA_256.java
/**
*the program about SHA_256
*outputting result writes into SHA_256.txt file
*entering msg reads from msg.txt file
*@author liulanag
*@version 1.0
*/
import java.io.*;
public class SHA_256 {
static String msg_binary=new String();//消息用二进制表示
static StringBuffer str2=new StringBuffer();//缓冲
static String H0="6a09e667";//初始值
static String H1="bb67ae85";
static String H2="3c6ef372";
static String H3="a54ff53a";
static String H4="510e527f";
static String H5="9b05688c";
static String H6="1f83d9ab";
static String H7="5be0cd19";
static String A,B,C,D,E,F,G,H;
static PrintWriter out;
static File file;
static FileReader fls;
static BufferedReader br;
static long begin;
static long end;
static String[] k=new String[64];
static String[] K={
"428a2f98","71374491","b5c0fbcf","e9b5dba5","3956c25b","59f111f1","923f82a4","ab1c5ed5",
"d807aa98","12835b01","243185be","550c7dc3","72be5d74","80deb1fe","9bdc06a7","c19bf174",
"e49b69c1","efbe4786","0fc19dc6","240ca1cc","2de92c6f","4a7484aa","5cb0a9dc","76f988da",
"983e5152","a831c66d","b00327c8","bf597fc7","c6e00bf3","d5a79147","06ca6351","14292967",
"27b70a85","2e1b2138","4d2c6dfc","53380d13","650a7354","766a0abb","81c2c92e","92722c85",
"a2bfe8a1","a81a664b","c24b8b70","c76c51a3","d192e819","d6990624","f40e3585","106aa070",
"19a4c116","1e376c08","2748774c","34b0bcb5","391c0cb3","4ed8aa4a","5b9cca4f","682e6ff3",
"748f82ee","78a5636f","84c87814","8cc70208","90befffa","a4506ceb","bef9a3f7","c67178f2"};
static String [] w=new String[80];
static int group_num=1;//组数
static int mod=0;//最后一组的原始长度
public static void main(String[] args) throws IOException {
try{
file=new File("msg.txt");
boolean createok;
if(!file.exists()) {//如果文件不存在,则在当前目录创建文件
System.out.println("the file does not exist! enter the message:");
createok=file.createNewFile();
out=new PrintWriter(new FileWriter(file));
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
out.println(stdin.readLine());
out.close();
}
fls = new FileReader(file);
br = new BufferedReader(fls);
String msg=new String();
msg=br.readLine();
begin=System.currentTimeMillis();
//BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
//String msg=stdin.readLine();
out=new PrintWriter(new FileWriter("SHA_256.txt"));
for(int i=0;i<64;i++)
k[i]=hexToBinary(K[i]);
msg_binary=stringToBinary(msg);
final int SIZE=msg_binary.length();//消息变成二进制后的长度
out.println(msg.length());
mod=SIZE%512;
out.println(msg_binary);
out.println(SIZE);
if(SIZE<448)
group_num=1;
else if(SIZE>=448&&SIZE<=512)
group_num=2;
else {
if(mod<448)
group_num=SIZE/512+1;
else
group_num=SIZE/512+2;
}
char[] cw=new char[512*group_num];
for(int i=0;i<SIZE;i++) {//填充位数
cw[i]=msg_binary.charAt(i);
}
String str1=new String(Integer.toBinaryString(SIZE));
if(SIZE<448) {
cw[SIZE]='1';
for(int i=SIZE+1;i<512*group_num-str1.length();i++) {
cw[i]='0';
}
for(int i=512*group_num-str1.length();i<512*group_num;i++) {
cw[i]=str1.charAt(i-512*group_num+str1.length());
}
}
if(SIZE>=448&&SIZE<=512) {
cw[SIZE]='1';
for(int i=SIZE+1;i<512*group_num-str1.length();i++) {
cw[i]='0';
}
for(int i=512*group_num-str1.length();i<512*group_num;i++) {
cw[i]=str1.charAt(i-512*group_num+str1.length());
}
}
if(SIZE>512) {
cw[SIZE]='1';
for(int i=SIZE+1;i<512*group_num-str1.length();i++) {
cw[i]='0';
}
for(int i=512*group_num-str1.length();i<512*group_num;i++) {
cw[i]=str1.charAt(i-512*group_num+str1.length());
}
}
str2=str2.delete(0,str2.length());//delete str2=null;
for(int i=0;i<512*group_num;i++) {
str2=str2.append(cw[i]);
}
out.println();
for(int n=0;n<group_num;n++){
out.println("第"+(n+1)+"组:");
//w[0] to w[80]
String str3=new String();//存放每一个分组的512位
str3=str2.substring(n*512,(n+1)*512).toString();//取每一组的512为
for(int i=0;i<16;i++) {
w[i]=str3.substring(i*32,(i+1)*32);
out.println("w"+i+" "+binaryToHex(w[i]));
}
for(int i=16;i<64;i++) {
w[i]=binaryplus(binaryplus(small_sigma_one(w[i-2]),w[i-7]),binaryplus(small_sigma_zero(w[i-15]),w[i-16]));
out.println("w"+i+" "+binaryToHex(w[i]));
}
A=new String(hexToBinary(H0));
B=new String(hexToBinary(H1));
C=new String(hexToBinary(H2));
D=new String(hexToBinary(H3));
E=new String(hexToBinary(H4));
F=new String(hexToBinary(H5));
G=new String(hexToBinary(H6));
H=new String(hexToBinary(H7));
calculate_sha_256(A,B,C,D,E,F,G,H);
}
}catch(FileNotFoundException fe) {
System.out.println("the file don't exist");
}catch(NullPointerException fe) {
System.out.println("the file is null,please inputting the context to the file");
}
end=System.currentTimeMillis();
System.out.println(H0+H1+H2+H3+H4);
System.out.println("运行时间"+(end-begin)+"ms");
out.close();
br.close();
fls.close();
}
//计算A,B,C,D,E,F,G,H函数
public static void calculate_sha_256(String A,String B,String C,String D,String E,String F,String G,String H) {
String temp1=new String();
String temp2=new String();
for(int i=0;i<64;i++) {
out.print("i="+i+" ");
temp1=T1(H,E,ch(E,F,G),w[i],k[i]);
temp2=binaryplus(temp1,T2(A,maj(A,B,C)));
H=G;
G=F;
F=E;
E=binaryplus(D,temp1);
D=C;
C=B;
B=A;
A=temp2;
display(A,B,C,D,E,F,G,H);
}
H0=binaryToHex(binaryplus(A,hexToBinary(H0)));
H1=binaryToHex(binaryplus(B,hexToBinary(H1)));
H2=binaryToHex(binaryplus(C,hexToBinary(H2)));
H3=binaryToHex(binaryplus(D,hexToBinary(H3)));
H4=binaryToHex(binaryplus(E,hexToBinary(H4)));
H5=binaryToHex(binaryplus(F,hexToBinary(H5)));
H6=binaryToHex(binaryplus(G,hexToBinary(H6)));
H7=binaryToHex(binaryplus(H,hexToBinary(H7)));
out.println(H0+" "+H1+" "+H2+" "+H3+" "+H4+" "+H5+" "+H6+" "+H7);
//System.out.println(H0+H1+H2+H3+H4+H5+H6+H7);
}
//从字符串到二进制
public static String stringToBinary(String str) {
StringBuffer str2=new StringBuffer();
for(int i=0;i<str.length();i++) {
str2=str2.append(fill_zero(Integer.toBinaryString(Integer.valueOf(str.charAt(i))),8));
}
return str2.toString();
}
//填充函数
public static String fill_zero(String str,int n) {
String str2=new String();
StringBuffer str1=new StringBuffer();
if(str.length()<n)
for(int i=0;i<n-str.length();i++) {
str2=str1.append('0').toString();
}
return str2+str;
}
//异或
public static String bit_df_or(String str1,String str2) {
String str=new String();
StringBuffer s=new StringBuffer();
for(int i=0;i<str1.length();i++) {
if(str1.charAt(i)==str2.charAt(i))
str=s.append('0').toString();
else
str=s.append('1').toString();
}
return str;
}
//同或
public static String bit_sa_or(String str1,String str2) {
String str=new String();
StringBuffer s=new StringBuffer();
for(int i=0;i<str1.length();i++) {
if(str1.charAt(i)==str2.charAt(i))
str=s.append('1').toString();
else
str=s.append('0').toString();
}
return str;
}
//与
public static String bit_and(String str1,String str2) {
String str=new String();
StringBuffer s=new StringBuffer();
for(int i=0;i<str1.length();i++) {
if(str1.charAt(i)=='0'||str2.charAt(i)=='0')
str=s.append('0').toString();
else
str=s.append('1').toString();
}
return str;
}
//或
public static String bit_or(String str1,String str2) {
String str=new String();
StringBuffer s=new StringBuffer();
for(int i=0;i<str1.length();i++) {
if(str1.charAt(i)=='1'||str2.charAt(i)=='1')
str=s.append('1').toString();
else
str=s.append('0').toString();
}
return str;
}
//非
public static String bit_non(String str1) {
String str=new String();
StringBuffer s=new StringBuffer();
for(int i=0;i<str1.length();i++) {
if(str1.charAt(i)=='0')
str=s.append('1').toString();
else
str=s.append('0').toString();
}
return str;
}
//循环左移n位
public static String rotl(String str,int n) {
String str1=str.substring(0,n);
String str2=str.substring(n);
return str2+str1;
}
//循环右移n位
public static String rotr(String str,int n) {
String str1=str.substring(str.length()-n);
String str2=str.substring(0,str.length()-n);
return str1+str2;
}
//右移n位
public static String shr(String str,int n) {
char[] fillZero=new char[n];
java.util.Arrays.fill(fillZero,'0');
String str1=str.substring(0,str.length()-n);
return new String(fillZero)+str1;
}
public static String ch(String str1,String str2,String str3) {
return bit_df_or(bit_and(str1,str2),bit_and(bit_non(str1),str3));
}
public static String maj(String str1,String str2,String str3) {
return bit_df_or(bit_df_or(bit_and(str1,str2),bit_and(str1,str3)),bit_and(str2,str3));
}
public static String big_sigma_zero(String str1) {
return bit_df_or(bit_df_or(rotr(str1,2),rotr(str1,13)),rotr(str1,22));
}
public static String big_sigma_one(String str1) {
return bit_df_or(bit_df_or(rotr(str1,6),rotr(str1,11)),rotr(str1,25));
}
public static String small_sigma_zero(String str1) {
return bit_df_or(bit_df_or(rotr(str1,7),rotr(str1,18)),shr(str1,3));
}
public static String small_sigma_one(String str1) {
return bit_df_or(bit_df_or(rotr(str1,17),rotr(str1,19)),shr(str1,10));
}
//相加
public static String binaryplus(String str1,String str2) {
char[] cstr=new char[32];
int flag=0;
for(int i=str1.length()-1;i>=0;i--) {
cstr[i]=(char)(((str1.charAt(i)-'0')+((str2.charAt(i)-'0'))+flag)%2+'0');
if(((str1.charAt(i)-'0')+(str2.charAt(i)-'0')+flag)>=2)
flag=1;
else
flag=0;
}
return new String(cstr);
}
//二进制到十六进制
public static String binaryToHex(String str) {
int temp=0;
StringBuffer st=new StringBuffer();
for(int i=0;i<str.length()/4;i++) {
temp=Integer.valueOf(str.substring(i*4,(i+1)*4),2);
st=st.append(Integer.toHexString(temp));
}
return st.toString();
}
//从十六进制到二进制
public static String hexToBinary(String str) {
StringBuffer st1=new StringBuffer();
String st=new String();
for(int i=0;i<str.length();i++){
switch(str.charAt(i)) {
case '0':st="0000";break;
case '1':st="0001";break;
case '2':st="0010";break;
case '3':st="0011";break;
case '4':st="0100";break;
case '5':st="0101";break;
case '6':st="0110";break;
case '7':st="0111";break;
case '8':st="1000";break;
case '9':st="1001";break;
case 'a':st="1010";break;
case 'b':st="1011";break;
case 'c':st="1100";break;
case 'd':st="1101";break;
case 'e':st="1110";break;
case 'f':st="1111";break;
default :break;
}
st1=st1.append(st);
}
return st1.toString();
}
//计算T1//liulang
public static String T1(String str_h,String str_e,String str_ch,String str_w,String str_k) {
return binaryplus(binaryplus(binaryplus(str_h,big_sigma_one(str_e)),binaryplus(str_ch,str_w)),str_k);
}
//计算T2
public static String T2(String str_a,String str_maj) {
return binaryplus(big_sigma_zero(str_a),str_maj);
}
//打印出A,B,C,D,E,F,G,H
public static void display(String A,String B,String C,String D,String E,String F,String G,String H) {
out.print("A="+binaryToHex(A)+" ");
out.print("B="+binaryToHex(B)+" ");
out.print("C="+binaryToHex(C)+" ");
out.print("D="+binaryToHex(D)+" ");
out.print("E="+binaryToHex(E)+" ");
out.print("F="+binaryToHex(F)+" ");
out.print("G="+binaryToHex(G)+" ");
out.print("H="+binaryToHex(H)+" ");
out.println();
}
}
分享到:
相关推荐
在Java中实现SHA-256加密算法,可以使用内置的`java.security.MessageDigest`类。这个过程涉及到几个关键步骤,包括创建`MessageDigest`实例、更新输入数据和获取哈希值。 首先,我们需要导入必要的Java库: ```...
标题中的"sha-256(java).rar_SHA_SHA-256 JAVA_Sha-256 java_sha-256_sha25"表明这是一个关于Java环境下实现SHA-256散列算法的压缩包文件。SHA-256是安全哈希算法(Secure Hash Algorithm)家族的一员,广泛用于数据...
在C++中实现SHA-256加密算法,我们需要了解其基本原理、步骤以及如何在代码中实现。 SHA-256算法的基本流程包括以下步骤: 1. **初始化哈希值**:首先,我们需要设置一组初始的哈希值,这些是固定的常量,由SHA-...
SHA-256是一种广泛使用的...总结起来,"SHA-256-Matlab-Implements SHA-256 Algorithm.zip"这个压缩包提供了在MATLAB环境下实现SHA-256算法的工具,帮助用户快速计算和验证数据的SHA-256散列值,从而加强数据安全性。
SHA-256算法对输入进行计算,产生一个256位的哈希值,通常以64个十六进制数字的形式呈现。由于其强大的抗碰撞性,目前在密码学中被广泛应用,包括TLS证书、数字签名和文件完整性校验。 “信息摘要算法示例”可能...
SHA-256的"sha256写法"可能指的是实现该算法的代码,这可能包括用C、Python、Java等编程语言编写的函数或类,它们会遵循上述的步骤,接受输入数据,然后计算并返回对应的SHA-256摘要。在实际应用中,开发者通常会...
下面我们将深入探讨SHA-256算法、其在JAVA中的实现以及如何进行文件加密。 SHA-256算法详解: SHA-256是由美国国家安全局(NSA)设计的,于2001年发布。它接受任意长度的输入(也称为预映射或消息),产生一个固定...
SHA算法有多个版本,包括SHA-1、SHA-256等,这里主要讨论的是SHA-256算法。SHA-256是SHA-2家族的一部分,其输出的哈希值为256位,也就是32个字节。 SHA-256算法的核心计算流程主要包括以下几个步骤: 1. **初始化...
同学用java写的SHA-1算法,我在原有基础上稍稍改进了一下。本算法可以对字符串进行加密,加密结果经多次验证无误,希望能对密码学感兴趣的同学有所帮助。
SHA-256则是SHA-2(安全哈希算法2)家族的一员,由美国国家安全局设计,用于数字签名和哈希函数,具有较高的安全性。 在Spring框架中,我们经常需要处理加密解密和签名验证的问题,以确保数据传输的安全性和完整性...
java实现的sha256加密算法
Java作为跨平台的编程语言,提供了对SHA-1算法的支持。 在Java中实现SHA-1,通常会用到`java.security.MessageDigest`类。这个类提供了一种标准的方式来计算各种消息摘要,包括SHA-1。下面是一个简单的SHA-1散列...
很难得的关于SHA-1算法应用书籍,这是我在做毕业设计期间找到的参考资料,欢迎大家下载使用!!
### 二、Java实现SHA-1算法 #### 1. 字符串和文件的哈希处理 在提供的代码中,主要实现了对字符串和文件进行SHA-1哈希计算的功能。这里通过一系列步骤来处理输入数据,包括二进制转换、填充等预处理操作,最终得到...
JavaScript(简称JS)是一种广泛用于Web开发的轻量级脚本语言,而SHA-1是一种常用的密码散列函数,能够将任意长度的信息映射为固定长度的摘要值。...对于新的项目,建议使用更安全的散列函数,如SHA-256或SHA-3。
SHA-256(安全哈希算法256位)是一种广泛使用的散列函数,用于生成消息的固定长度摘要,通常用于验证数据完整性。在这个场景中,我们讨论的是如何结合盐值(salt)使用SHA-256进行更安全的加密操作,以及如何使用AES...
SHA-256算法通常需要64轮处理。 4. **输出结果**:最后,这8个变量被组合成最终的哈希值,即256位的哈希摘要。 在安全领域,SHA-2常用于数字签名、完整性校验和密码存储等方面。例如,当下载软件时,可以使用SHA-2...
在Java编程环境中,SHA256withRSA是一种广泛使用的安全算法,它结合了SHA-256哈希函数和RSA非对称加密算法,用于确保数据的完整性和身份验证。这个"JAVA-SHA256withRSA.java"文件提供了一个完整的工具类RSAUtils,...
ava.security.MessageDigest类用于为应用程序提供信息摘要算法的功能,如 MD5 或 SHA 算法。简单点说就是用于生成散列码。信息摘要是安全的单向哈希函数,它接收任意大小的数据,输出固定长度的哈希值。关于信息摘要...
2. **算法兼容**:确保在Java和.NET中使用相同的算法标识符,如"SHA256withRSA"。在.NET中,可能需要使用`CryptoConfig.MapNameToOID`方法来映射算法名称到其对应的Object Identifier(OID)。 3. **字节序处理**:...