java代码转e

yylgy

package com.palmfun.common.message;

import cn.p000uc.gamesdk.p006f.C0086f;
import com.palmfun.common.cipher.XxTea;
import com.palmfun.common.exception.MessageException;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;

/* loaded from: classes.dex */
public abstract class AbstractMessage implements Message {
    public String sessionId;
    public short messageId = 0;
    public short version = 1;
    public int sequenceId = 0;
    public byte encryption = 0;
    public byte compress = 0;
    public int respCode = 0;
    public String respDesc = null;
    public int respStatus = 0;
    private int loginId = -1;
    private int serverId = -1;
    private String key = C0086f.f389a;

    @Override // com.palmfun.common.message.Message
    public abstract void decode(ChannelBuffer channelBuffer);

    @Override // com.palmfun.common.message.Message
    public abstract void encode(ChannelBuffer channelBuffer);

    public static Message decodeMessage(ChannelBuffer ib, String ip) throws MessageException {
        Short id = Short.valueOf(ib.readShort());
        MessageType type = MessageType.get(id.shortValue());
        if (type == null) {
            String errorMsg = "no message:" + id;
            throw new RuntimeException(errorMsg);
        }
        Class<? extends Message> meta = type.getMsgMeta();
        try {
            Message message = meta.newInstance();
            message.setVersion(ib.readShort());
            message.setSequenceId(ib.readInt());
            message.setEncryption(ib.readByte());
            message.setCompress(ib.readByte());
            message.setRespCode(ib.readInt());
            message.setRespStatus(ib.readInt());
            message.setLoginId(ib.readInt());
            message.setSessionId(readString(ib));
            message.setServerId(ib.readInt());
            message.setKey(readString(ib));
            System.out.println("messageId=" + ((int) message.getMessageId()));
            System.out.println("key=" + message.getKey());
            if (message.getEncryption() == 0) {
                message.decode(ib);
            } else {
                message.decode(ib, ip);
            }
            return message;
        } catch (Exception ex) {
            ex.printStackTrace();
            throw new MessageException("\u5b9e\u4f8b\u5316\u6d88\u606f\u5f02\u5e38\uff1a" + ex.getMessage());
        }
    }

    public static void encodeMessage(Message message, ChannelBuffer ob, String ip) {
        ob.writeShort(message.getMessageId());
        ob.writeShort(message.getVersion());
        ob.writeInt(message.getSequenceId());
        ob.writeByte(message.getEncryption());
        ob.writeByte(message.getCompress());
        ob.writeInt(message.getRespCode());
        ob.writeInt(message.getRespStatus());
        ob.writeInt(message.getLoginId());
        writeString(ob, message.getSessionId());
        ob.writeInt(message.getServerId());
        writeString(ob, message.getKey());
        System.out.println("messageId1=" + ((int) message.getMessageId()));
        System.out.println("key1=" + message.getKey());
        if (message.getRespCode() == 0) {
            if (message.getEncryption() == 0) {
                message.encode(ob);
                return;
            } else {
                message.encode(ob, MessageUtil.getClientKey(ip));
                return;
            }
        }
        if (message.getRespCode() > 0) {
            if (message.getEncryption() == 0) {
                message.encode(ob, (Boolean) true);
                return;
            } else {
                message.encode(ob, MessageUtil.getClientKey(ip), true);
                return;
            }
        }
        if (message.getEncryption() == 0) {
            message.encode(ob);
        } else {
            message.encode(ob, MessageUtil.getClientKey(ip));
        }
    }

    @Override // com.palmfun.common.message.Message
    public void encode(ChannelBuffer ob, Boolean error) {
    }

    @Override // com.palmfun.common.message.Message
    public void decode(ChannelBuffer ib, String ip) {
    }

    @Override // com.palmfun.common.message.Message
    public void encode(ChannelBuffer ob, String key) {
    }

    @Override // com.palmfun.common.message.Message
    public void encode(ChannelBuffer ob, String key, Boolean error) {
    }

    @Override // com.palmfun.common.message.Message
    public void setMessageId(short messageId) {
        this.messageId = messageId;
    }

    @Override // com.palmfun.common.message.Message
    public short getMessageId() {
        return this.messageId;
    }

    @Override // com.palmfun.common.message.Message
    public void setVersion(short version) {
        this.version = version;
    }

    @Override // com.palmfun.common.message.Message
    public short getVersion() {
        return this.version;
    }

    @Override // com.palmfun.common.message.Message
    public void setSequenceId(int sequenceId) {
        this.sequenceId = sequenceId;
    }

    @Override // com.palmfun.common.message.Message
    public int getSequenceId() {
        return this.sequenceId;
    }

    @Override // com.palmfun.common.message.Message
    public void setEncryption(byte encryption) {
        this.encryption = encryption;
    }

    @Override // com.palmfun.common.message.Message
    public byte getEncryption() {
        return this.encryption;
    }

    @Override // com.palmfun.common.message.Message
    public void setCompress(byte compress) {
        this.compress = compress;
    }

    @Override // com.palmfun.common.message.Message
    public byte getCompress() {
        return this.compress;
    }

    @Override // com.palmfun.common.message.Message
    public int getRespCode() {
        return this.respCode;
    }

    @Override // com.palmfun.common.message.Message
    public void setRespCode(int erespCodespCode) {
        this.respCode = erespCodespCode;
    }

    @Override // com.palmfun.common.message.Message
    public String getRespDesc() {
        return this.respDesc;
    }

    @Override // com.palmfun.common.message.Message
    public void setRespDesc(String respDesc) {
        this.respDesc = respDesc;
    }

    @Override // com.palmfun.common.message.Message
    public int getRespStatus() {
        return this.respStatus;
    }

    @Override // com.palmfun.common.message.Message
    public void setRespStatus(int respStatus) {
        this.respStatus = respStatus;
    }

    @Override // com.palmfun.common.message.Message
    public int getLoginId() {
        return this.loginId;
    }

    @Override // com.palmfun.common.message.Message
    public void setLoginId(int loginId) {
        this.loginId = loginId;
    }

    public static String readString(ChannelBuffer ib) {
        int temp = ib.readInt();
        byte[] bytes = new byte[temp];
        ib.readBytes(bytes);
        return new String(bytes);
    }

    public static void writeString(ChannelBuffer ob, String str) {
        if (str == null) {
            str = C0086f.f389a;
        }
        byte[] bytes = str.getBytes();
        ob.writeInt(bytes.length);
        ob.writeBytes(bytes);
    }

    public static void writeString(ChannelBuffer ob, byte[] bytes) {
        ob.writeInt(bytes.length);
        ob.writeBytes(bytes);
    }

    public static void writeString(ChannelBuffer ob, byte[] bytes, String key) {
        byte[] target = XxTea.encrypt(bytes, key.getBytes());
        ob.writeInt(target.length);
        ob.writeBytes(target);
    }

    public static ChannelBuffer decryption(ChannelBuffer ib, String ip) {
        byte[] info = new byte[ib.writerIndex() - ib.readerIndex()];
        ib.readBytes(info);
        String key = MessageUtil.getClientKey(ip);
        System.out.println("server key=" + key);
        byte[] dyInfo = XxTea.decrypt(info, "2e5b4e6e159689fbd71e2fe5aa3194a3".getBytes());
        ChannelBuffer dynamic = ChannelBuffers.dynamicBuffer(dyInfo.length);
        dynamic.setBytes(0, dyInfo);
        dynamic.writerIndex(dyInfo.length);
        return dynamic;
    }

    public static void encryption(ChannelBuffer ob, ChannelBuffer dynamic, String key) {
        byte[] src = dynamic.array();
        byte[] enc = XxTea.encrypt(src, key.getBytes());
        ob.writeBytes(enc);
    }

    @Override // com.palmfun.common.message.Message
    public String getSessionId() {
        return this.sessionId;
    }

    @Override // com.palmfun.common.message.Message
    public void setSessionId(String sessionId) {
        this.sessionId = sessionId;
    }

    @Override // com.palmfun.common.message.Message
    public int getServerId() {
        return this.serverId;
    }

    @Override // com.palmfun.common.message.Message
    public void setServerId(int serverId) {
        this.serverId = serverId;
    }

    @Override // com.palmfun.common.message.Message
    public String getKey() {
        return this.key;
    }

    @Override // com.palmfun.common.message.Message
    public void setKey(String key) {
        this.key = key;
    }

    public String isNullString(String str) {
        if (str == null) {
            return C0086f.f389a;
        }
        return str;
    }
}

我想知道这个java代码的加密，这个是tcp的，我看不懂流程

后弦

.版本 2

.支持库 eNet

.数据类型 Hid_StatusPacket, , 公开
    .成员 success, 整数型
    .成员 errorCode, 整数型
.数据类型结束

.数据类型 MessageType, , 公开
    .成员 id, 整数型
    .成员 msgMeta, 类型信息
.数据类型结束

.数据类型 Message, , 抽象, 继承 自定义基类
.抽象子程序 decode, , 公开, 解码消息
    .参数 channelBuffer, 字节集
.抽象子程序 encode, , 公开, 编码消息
    .参数 channelBuffer, 字节集
.子程序 setMessageId, , 公开
    .参数 messageId, 整数型
.子程序 getMessageId, 整数型, 公开
.子程序 setVersion, , 公开
    .参数 version, 整数型
.子程序 getVersion, 整数型, 公开
.子程序 setSequenceId, , 公开
    .参数 sequenceId, 整数型
.子程序 getSequenceId, 整数型, 公开
.子程序 setEncryption, , 公开
    .参数 encryption, 字节型
.子程序 getEncryption, 字节型, 公开
.子程序 setCompress, , 公开
    .参数 compress, 字节型
.子程序 getCompress, 字节型, 公开
.子程序 getRespCode, 整数型, 公开
.子程序 setRespCode, , 公开
    .参数 respCode, 整数型
.子程序 getRespDesc, 文本型, 公开
.子程序 setRespDesc, , 公开
    .参数 respDesc, 文本型
.子程序 getRespStatus, 整数型, 公开
.子程序 setRespStatus, , 公开
    .参数 respStatus, 整数型
.子程序 getLoginId, 整数型, 公开
.子程序 setLoginId, , 公开
    .参数 loginId, 整数型
.子程序 getSessionId, 文本型, 公开
.子程序 setSessionId, , 公开
    .参数 sessionId, 文本型
.子程序 getServerId, 整数型, 公开
.子程序 setServerId, , 公开
    .参数 serverId, 整数型
.子程序 getKey, 文本型, 公开
.子程序 setKey, , 公开
    .参数 key, 文本型
.子程序 isNullString, 文本型, 公开
    .参数 str, 文本型
.数据类型结束

.数据类型 AbstractMessage, , 继承 Message
.成员 sessionId, 文本型
.成员 messageId, 整数型
.成员 version, 整数型
.成员 sequenceId, 整数型
.成员 encryption, 字节型
.成员 compress, 字节型
.成员 respCode, 整数型
.成员 respDesc, 文本型
.成员 respStatus, 整数型
.成员 loginId, 整数型
.成员 serverId, 整数型
.成员 key, 文本型

.子程序 _构造子, , 公开
    .局部变量 defaultKey, 文本型
    defaultKey ＝ “default_key_value”  ; 这里替换为实际的默认密钥值
    登录ID ＝ －1
    服务器ID ＝ －1
    密钥 ＝ defaultKey
    版本 ＝ 1

.子程序 decode, , 公开, 解码消息
    .参数 channelBuffer, 字节集

.子程序 encode, , 公开, 编码消息
    .参数 channelBuffer, 字节集

.子程序 decode, , 公开, 解码消息（带IP）
    .参数 channelBuffer, 字节集
    .参数 ip, 文本型

.子程序 encode, , 公开, 编码消息（带加密）
    .参数 channelBuffer, 字节集
    .参数 key, 文本型

.子程序 encode, , 公开, 编码消息（带加密和错误标志）
    .参数 channelBuffer, 字节集
    .参数 key, 文本型
    .参数 error, 布尔型

.子程序 setMessageId, , 公开
    .参数 messageId, 整数型
    信息标识符 ＝ messageId

.子程序 getMessageId, 整数型, 公开
    返回 (信息标识符)

.子程序 setVersion, , 公开
    .参数 version, 整数型
    版本 ＝ version

.子程序 getVersion, 整数型, 公开
    返回 (版本)

.子程序 setSequenceId, , 公开
    .参数 sequenceId, 整数型
    序列号 ＝ sequenceId

.子程序 getSequenceId, 整数型, 公开
    返回 (序列号)

.子程序 setEncryption, , 公开
    .参数 encryption, 字节型
    加密方式 ＝ encryption

.子程序 getEncryption, 字节型, 公开
    返回 (加密方式)

.子程序 setCompress, , 公开
    .参数 compress, 字节型
    压缩方式 ＝ compress

.子程序 getCompress, 字节型, 公开
    返回 (压缩方式)

.子程序 getRespCode, 整数型, 公开
    返回 (响应代码)

.子程序 setRespCode, , 公开
    .参数 respCode, 整数型
    响应代码 ＝ respCode

.子程序 getRespDesc, 文本型, 公开
    返回 (响应描述)

.子程序 setRespDesc, , 公开
    .参数 respDesc, 文本型
    响应描述 ＝ respDesc

.子程序 getRespStatus, 整数型, 公开
    返回 (响应状态)

.子程序 setRespStatus, , 公开
    .参数 respStatus, 整数型
    响应状态 ＝ respStatus

.子程序 getLoginId, 整数型, 公开
    返回 (登录ID)

.子程序 setLoginId, , 公开
    .参数 loginId, 整数型
    登录ID ＝ loginId

.子程序 getSessionId, 文本型, 公开
    返回 (会话ID)

.子程序 setSessionId, , 公开
    .参数 sessionId, 文本型
    会话ID ＝ sessionId

.子程序 getServerId, 整数型, 公开
    返回 (服务器ID)

.子程序 setServerId, , 公开
    .参数 serverId, 整数型
    服务器ID ＝ serverId

.子程序 getKey, 文本型, 公开
    返回 (密钥)

.子程序 setKey, , 公开
    .参数 key, 文本型
    密钥 ＝ key

.子程序 isNullString, 文本型, 公开
    .参数 str, 文本型
    如果 (str ＝ “”) 则
        返回 (“default_key_value”)  ; 这里替换为实际的默认密钥值
    否则
        返回 (str)
    结束 如果

.子程序 readString, 文本型, 公开
    .参数 ib, 字节集
    .局部变量 temp, 整数型
    .局部变量 bytes, 字节集
    temp ＝ 取字节集整数 (ib, )
    bytes ＝ 取字节集部分 (ib, , temp)
    返回 (到文本 (bytes))

.子程序 writeString, , 公开
    .参数 ob, 字节集
    .参数 str, 文本型
    .局部变量 bytes, 字节集
    如果 (str ＝ “”) 则
        str ＝ “default_key_value”  ; 这里替换为实际的默认密钥值
    结束 如果
    bytes ＝ 到字节集 (str)
    写入字节集整数 (ob, 取字节集长度 (bytes))
    写入字节集 (ob, bytes)

.子程序 writeString, , 公开
    .参数 ob, 字节集
    .参数 bytes, 字节集
    写入字节集整数 (ob, 取字节集长度 (bytes))
    写入字节集 (ob, bytes)

.子程序 writeString, , 公开
    .参数 ob, 字节集
    .参数 bytes, 字节集
    .参数 key, 文本型
    .局部变量 target, 字节集
    target ＝ XXTea加密 (bytes, 到字节集 (key))
    写入字节集整数 (ob, 取字节集长度 (target))
    写入字节集 (ob, target)

.子程序 decryption, 字节集, 公开
    .参数 ib, 字节集
    .参数 ip, 文本型
    .局部变量 info, 字节集
    .局部变量 key, 文本型
    .局部变量 dyInfo, 字节集
    .局部变量 dynamic, 字节集
    info ＝ 取字节集部分 (ib, , ib.写位置 － ib.读位置)
    key ＝ 获取客户Duan密钥 (ip)
    dyInfo ＝ XXTea解密 (info, 到字节集 (“2e5b4e6e159689fbd71e2fe5aa3194a3”))
    dynamic ＝ 创建动态字节集 (取字节集长度 (dyInfo))
    写入字节集 (dynamic, dyInfo)
    dynamic.写位置 ＝ 取字节集长度 (dyInfo)
    返回 (dynamic)

.子程序 encryption, , 公开
    .参数 ob, 字节集
    .参数 dynamic, 字节集
    .参数 key, 文本型
    .局部变量 src, 字节集
    .局部变量 enc, 字节集
    src ＝ dynamic.数组
    enc ＝ XXTea加密 (src, 到字节集 (key))
    写入字节集 (ob, enc)

.子程序 XXTea加密, 字节集, 私有
    .参数 data, 字节集
    .参数 key, 字节集
    ; 这里实现XXTea加密算法，具体实现省略
    返回 (data)  ; 替换为实际的加密结果

.子程序 XXTea解密, 字节集, 私有
    .参数 data, 字节集
    .参数 key, 字节集
    ; 这里实现XXTea解密算法，具体实现省略
    返回 (data)  ; 替换为实际的解密结果

.子程序 获取客户Duan密钥, 文本型, 私有
    .参数 ip, 文本型
    ; 这里根据IP获取客户Duan密钥，具体实现省略
    返回 (“client_key”)  ; 替换为实际的密钥

yylgy

public static ChannelBuffer decryption(ChannelBuffer ib, String ip) {         byte[] info = new byte[ib.writerIndex() - ib.readerIndex()];         ib.readBytes(info);         String key = MessageUtil.getClientKey(ip);         System.out.println("server key=" + key);         byte[] dyInfo = XxTea.decrypt(info, "2e5b4e6e159689fbd71e2fe5aa3194a3".getBytes());         ChannelBuffer dynamic = ChannelBuffers.dynamicBuffer(dyInfo.length);         dynamic.setBytes(0, dyInfo);         dynamic.writerIndex(dyInfo.length);         return dynamic;     }

yylgy

我想在易语言里面写出这个解密的代码，但是看不懂这个java，有没有大佬解答一下

真IKUN

有偿可找

JueWar

定制联系我