SIPC认证算法java实现

SIPC的认证算法，支持SHA1和MD5。 



import java.io.UnsupportedEncodingException; 
import java.util.Calendar; 
import java.util.GregorianCalendar; 
import java.util.Random; 

/** 
* @author zackel 
* @date 2007-11-22 21:38:07 
* @project 
*/ 
public class GenAuthResponse { 
// Fields 
private String cnonce; 
private String domain; 
private String nonce; 
private String password; 
private static Random random; 
private String sid; 
private boolean usingSHA1=false; 
private String salt; 
private String encryptPassword; 

public void setSalt(String salt) { 
this.salt = salt; 
} 

public String getEncryptPassword() { 
return encryptPassword; 
} 

public void setEncryptPassword(String encryptPassword) { 
this.encryptPassword = encryptPassword; 
} 

public String getSalt() { 
return salt; 
} 

// public void setSalt(String salt) { 
// this.salt = salt; 
// } 

public boolean isUsingSHA1() { 
return usingSHA1; 
} 

public void setUsingSHA1(boolean usingSHA1) { 
this.usingSHA1 = usingSHA1; 
} 

public String getCnonce() { 

return this.cnonce; 
} 

public void setCnonce(String cnonce) { 
this.cnonce = cnonce; 
} 

public String getDomain() { 
return domain; 
} 

public void setDomain(String domain) { 
this.domain = domain; 
} 

public String getNonce() { 
return nonce; 
} 

public void setNonce(String nonce) { 
this.nonce = nonce; 
} 

public String getPassword() { 
return password; 
} 

public void setPassword(String password) { 
this.password = password; 
} 

public String getSid() { 
return sid; 
} 

public void setSid(String sid) { 
this.sid = sid; 
} 

// Methods 
public GenAuthResponse(String sid, String password, String domain, String nonce) 
{ 
this.sid = sid; 
this.password = password; 
this.domain = domain; 
this.nonce = nonce; 


Calendar cal = new GregorianCalendar(); 
int seed = cal.get(Calendar.DAY_OF_YEAR) * 0xf4240; 
seed += cal.get(Calendar.HOUR) * 0x2710; 
seed += cal.get(Calendar.MINUTE) * 100; 
seed += cal.get(Calendar.SECOND); 
// random = new Random(System.currentTimeMillis()); 

random = new Random(seed); 
this.cnonce = GenCNonce(); 
this.salt=GenSalt(); 
// System.out.println(salt); 
} 

private static String BinToHex(byte[] binary) 
{ 
// StringBuilder builder = new StringBuilder(); 
// for(byte num : binary) 
// { 
// int n = num; 
// if (n < 0) 
// n = n &0xff; 
// 
// if ((int)n > 15) 
// { 
// builder.append(String.format("%X",n)); 
// 
// } 
// else 
// { 
// builder.append(String.format("0%X",n)); 
// 
// } 
// } 
//// System.out.println(builder.toString()); 
// return builder.toString(); 
if (binary == null) 
return "null"; 
if (binary.length == 0) 
return ""; 

StringBuilder buf = new StringBuilder(); 

for (int i = 0; i < binary.length; i++) { 
if (binary[i] < 0) 
buf.append(Integer.toHexString(binary[i]&0xff)); 
else if (binary[i] < 16) { 
buf.append('0'); 
buf.append(Integer.toHexString(binary[i])); 
} else { 
buf.append(Integer.toHexString(binary[i])); 
} 
} 

return buf.toString().toUpperCase(); 
} 

private String GenH1(byte[] key) 
{ 
String s = String.format(":%s:%s", this.nonce, this.getCnonce()); 
// System.out.println("nonce:"+this.nonce ); 
// System.out.println("Cnonce:"+this.getCnonce()); 
// System.out.println(s); 
byte[] bytes; 
try { 
// bytes = s.getBytes("UTF-8"); 
bytes=new String(s.getBytes(),"utf-8").getBytes(); 

// System.out.println("h1 bytes:"+this.BinToHex(bytes)); 
byte[] array = new byte[key.length + bytes.length]; 
System.arraycopy(key,0,array,0,key.length); 
System.arraycopy(bytes, 0, array, key.length, bytes.length); 

// System.out.println("h1 array:"+this.BinToHex(array)); 
return MD5ToHex(array); 
} catch (UnsupportedEncodingException e) { 
e.printStackTrace(); 
} 
return null; 

} 

private String GenH2() 
{ 
String s = String.format("REGISTER:%s", this.sid); 
// System.out.println(s); 
try { 

// return MD5ToHex(s.getBytes("UTF-8")); 
return MD5ToHex(new String(s.getBytes(),"utf-8").getBytes()); 
} catch (UnsupportedEncodingException e) { 
e.printStackTrace();  
 
} 
return null; 
} 

private byte[] GenKey() 
{ 
if(this.usingSHA1==true){ 
String s1 = String.format("%s:%s:", this.sid, this.domain); 
// System.out.println(s1); 
try { 
this.encryptPassword=DoHashPassword(this.password); 
// System.out.println("GenKey enc psw:"); 
// System.out.println(this.encryptPassword); 

byte[] bytes=(new String(s1.getBytes(),"utf-8").getBytes()); 
// System.out.println("GenKey bytes:"+BinToHex(bytes)); 
byte[] src=this.HexToBin(this.encryptPassword.substring(8));//和C#定义不一样？ 
// System.out.println("psw0-8:"+BinToHex(src)); 
// byte[] src=this.HexToBin(this.salt); 
byte[] dst=new byte[bytes.length +src.length ]; 
System.arraycopy(bytes,0,dst,0,bytes.length); 
System.arraycopy(src,0,dst,bytes.length,src.length); 
// System.out.println("GenKey dst:"+BinToHex(dst)); 
return new SHA1().getDigestOfBytes(dst); 

} catch (UnsupportedEncodingException e) { 
// TODO 自动生成 catch 块 
e.printStackTrace(); 
} 

} 
String s = String.format("%s:%s:%s", this.sid, this.domain, this.password); 
// System.out.println(s); 
try { 
// return MD5(s.getBytes("UTF-8")); 
return MD5(new String(s.getBytes(),"utf-8").getBytes()); 
} catch (UnsupportedEncodingException e) { 

e.printStackTrace(); 
} 
return null; 
} 

public String GenResponse() 
{ 
byte[] key = this.GenKey(); 
// System.out.println("Key:"); 
// System.out.println(this.BinToHex(key)); 
String str = this.GenH1(key); 
// System.out.println("H1:"); 
// System.out.println(str); 
String str2 = this.GenH2(); 
// System.out.println("H2:"); 
// System.out.println(str2); 
return this.GenResponse(str, str2); 
} 

private String GenResponse(String h1, String h2) 
{ 
String s = String.format("%s:%s:%s", h1, this.nonce, h2); 
// System.out.println(s); 
try { 
// return MD5ToHex(s.getBytes("UTF-8")); 
return MD5ToHex(new String(s.getBytes(),"utf-8").getBytes()); 
} catch (UnsupportedEncodingException e) { 

e.printStackTrace(); 
} 
return null; 
} 

private String GenCNonce() 
{ 
int num = 0; 
int num2 = 0; 
int num3 = 0; 
int num4 = 0; 
synchronized (random) 
{ 
num = random.nextInt(); 
num2 = random.nextInt(); 
num3 = random.nextInt(); 
num4 = random.nextInt(); 
} 
if ((num >> 0x18) < 0x10) 
{ 

num += 0x10000000; 
} 
if ((num2 >> 0x18) < 0x10) 
{ 
num2 += 0x10000000; 
} 
if ((num3 >> 0x18) < 0x10) 
{ 
num3 += 0x10000000; 
} 
if ((num4 >> 0x18) < 0x10) 
{ 
num4 += 0x10000000; 
} 
return String.format("%X%X%X%X", new Object[] { num, num2, num3, num4 }); 
// 
} 


private static byte[] HexToBin(String hex) 
{ 
hex=hex.toUpperCase(); 
if ((hex == null) || (hex.length() < 1)) 
{ 
return new byte[0]; 
} 
int num = hex.length() / 2; 
byte[] buffer = new byte[num]; 
num *= 2; 
for (int i = 0; i < num; i++) 
{ 
// System.out.println(hex.substring(i, i+2)); 
char c1,c2; 
c1=hex.substring(i,i+1).charAt(0); 
c2=hex.substring(i+1, i+2).charAt(0); 
// System.out.println(c1); 
if(c1>='A') 
c1=(char) (10+c1-'A'); 
else 
c1=(char) (c1-'0'); 
if(c2>='A') 
c2=(char) (10+c2-'A'); 
else 
c2=(char) (c2-'0'); 

// System.out.println(c1-'A'); 
// System.out.println(c2); 
// System.out.println(c1*16+c2); 
int num3=c1*16+c2; 
// int num3 = Integer.parseInt(hex.substring(i, i+2)); 
buffer[i / 2] = (byte) num3; 
i++; 

} 
// System.out.println(BinToHex(buffer)); 
return buffer; 
} 

private byte[] MD5(byte[] data) 
{ 
return MD5Util.MD5Encode(data); 
} 

private String MD5ToHex(byte[] data) 
{ 
// data = MD5(data); 
return BinToHex(MD5(data)); 
} 

public String DoHashPassword(String _password){ 
try { 
return DoHashPassword(new String(_password.getBytes(),"utf-8").getBytes(),this.HexToBin(this.salt)); 
} catch (UnsupportedEncodingException e) { 
e.printStackTrace(); 
} 
return null; 

} 
public String DoHashPassword(byte[] password, byte[] b0) 
{ 
SHA1 sha=SHA1.Create(); 


byte[] src = sha.getDigestOfBytes(password); 
// System.out.println("psw sha1:"); 
// System.out.println(this.BinToHex(src)); 
for (int i = 0; i < password.length; i++) 
{ 
password[i] = 0; 
} 
byte[] dst = new byte[b0.length + src.length]; 
System.arraycopy(b0, 0, dst, 0, b0.length); 
System.arraycopy(src, 0, dst, b0.length, src.length); 
byte[] buffer3 = sha.getDigestOfBytes(dst); 

// System.out.println("buffer3 sha1:"); 
// System.out.println(this.BinToHex(buffer3)); 

byte[] buffer4 = new byte[b0.length + buffer3.length]; 
System.arraycopy(b0, 0, buffer4, 0, b0.length); 
System.arraycopy(buffer3, 0, buffer4, b0.length, buffer3.length); 
// System.out.println("enc psw:"); 
// System.out.println(this.BinToHex(buffer4)); 

return this.BinToHex(buffer4); 

} 

public String GenSalt(){ 
byte[] salt = new byte[4]; 

synchronized (random) 
{ 
salt[0] = (byte)random.nextInt(255); 
salt[1] = (byte)random.nextInt(255); 
salt[2] = (byte)random.nextInt(255); 
salt[3] = (byte)random.nextInt(255); 
// System.out.println(salt[3]); 
return this.BinToHex(salt); 
// return salt; 
} 



} 
// public static String EncodePassword(byte[] password, byte[] b0) 
// { 
// using (SHA1 sha = SHA1.Create()) 
// { 
// byte[] src = sha.ComputeHash(password); 
// for (int i = 0; i < password.Length; i++) 
// { 
// password[i] = 0; 
// } 
// byte[] dst = new byte[b0.Length + src.Length]; 
// Buffer.BlockCopy(b0, 0, dst, 0, b0.Length); 
// Buffer.BlockCopy(src, 0, dst, b0.Length, src.Length); 
// byte[] buffer3 = sha.ComputeHash(dst); 
// byte[] buffer4 = new byte[b0.Length + buffer3.Length]; 
// Buffer.BlockCopy(b0, 0, buffer4, 0, b0.Length); 
// Buffer.BlockCopy(buffer3, 0, buffer4, b0.Length, buffer3.Length); 
// return BinaryToHex(buffer4); 
// } 
// } 
// public static String BinaryToHex(byte[] binary) 
// { 
// StringBuilder builder = new StringBuilder(); 
// for(byte num:binary) 
// { 
// if (num > 15) 
// { 
// builder.("{0:X}", num); 
// } 
// else 
// { 
// builder.AppendFormat("0{0:X}", num); 
// } 
// } 
// return builder.toString(); 
// } 

// public static void main(String[] args){ 
// GenAuthResponse genAuthResponse=new GenAuthResponse("759909","A","fetion.com.cn", "250BA679516452E860C02B1638D52849"); 
// genAuthResponse.setUsingSHA1(true); 
// genAuthResponse.setCnonce("798AC8BD240DABB21C9259C8148373F2"); 
// genAuthResponse.setSalt("FD761703"); 
// 
//// genAuthResponse.HexToBin("E0FF0100"); 
// System.out.println(genAuthResponse.GenResponse()); 
//// System.out.println(genAuthResponse.getCnonce()); 
// 
//// Random random = new Random(10); 
//// int i=random.nextInt(9); 
// int num3; 
//// System.out.println(num3 = Integer.parseInt("0x5A")); 
// 
// } 
}