Crypt.java

net.minecraft.util.Crypt

信息

• 全限定名：net.minecraft.util.Crypt
• 类型：public class
• 包：net.minecraft.util
• 源码路径：src/main/java/net/minecraft/util/Crypt.java
• 起始行号：L28
• 职责：

  TODO

字段/常量

• SYMMETRIC_ALGORITHM

  • 类型: String
  • 修饰符: private static final
  • 源码定位: L29
  • 说明:

    TODO

• SYMMETRIC_BITS

  • 类型: int
  • 修饰符: private static final
  • 源码定位: L30
  • 说明:

    TODO

• ASYMMETRIC_ALGORITHM

  • 类型: String
  • 修饰符: private static final
  • 源码定位: L31
  • 说明:

    TODO

• ASYMMETRIC_BITS

  • 类型: int
  • 修饰符: private static final
  • 源码定位: L32
  • 说明:

    TODO

• BYTE_ENCODING

  • 类型: String
  • 修饰符: private static final
  • 源码定位: L33
  • 说明:

    TODO

• HASH_ALGORITHM

  • 类型: String
  • 修饰符: private static final
  • 源码定位: L34
  • 说明:

    TODO

• SIGNING_ALGORITHM

  • 类型: String
  • 修饰符: public static final
  • 源码定位: L35
  • 说明:

    TODO

• SIGNATURE_BYTES

  • 类型: int
  • 修饰符: public static final
  • 源码定位: L36
  • 说明:

    TODO

• PEM_RSA_PRIVATE_KEY_HEADER

  • 类型: String
  • 修饰符: private static final
  • 源码定位: L37
  • 说明:

    TODO

• PEM_RSA_PRIVATE_KEY_FOOTER

  • 类型: String
  • 修饰符: private static final
  • 源码定位: L38
  • 说明:

    TODO

• RSA_PUBLIC_KEY_HEADER

  • 类型: String
  • 修饰符: public static final
  • 源码定位: L39
  • 说明:

    TODO

• RSA_PUBLIC_KEY_FOOTER

  • 类型: String
  • 修饰符: private static final
  • 源码定位: L40
  • 说明:

    TODO

• MIME_LINE_SEPARATOR

  • 类型: String
  • 修饰符: public static final
  • 源码定位: L41
  • 说明:

    TODO

• MIME_ENCODER

  • 类型: Encoder
  • 修饰符: public static final
  • 源码定位: L42
  • 说明:

    TODO

• PUBLIC_KEY_CODEC

  • 类型: Codec<PublicKey>
  • 修饰符: public static final
  • 源码定位: L43
  • 说明:

    TODO

• PRIVATE_KEY_CODEC

  • 类型: Codec<PrivateKey>
  • 修饰符: public static final
  • 源码定位: L50
  • 说明:

    TODO

内部类/嵌套类型

• net.minecraft.util.Crypt.ByteArrayToKeyFunction

  • 类型: interface
  • 修饰符: private
  • 源码定位: L197
  • 说明:

    TODO

• net.minecraft.util.Crypt.SaltSignaturePair

  • 类型: record
  • 修饰符: public
  • 源码定位: L201
  • 说明:

    TODO

• net.minecraft.util.Crypt.SaltSupplier

  • 类型: class
  • 修饰符: public static
  • 源码定位: L222
  • 说明:

    TODO

构造器

• 无

方法

下面的方法块按源码顺序生成。

public static SecretKey generateSecretKey() @ L58

• 方法名：generateSecretKey
• 源码定位：L58
• 返回类型：SecretKey
• 修饰符：public static

参数:

• 无

说明:

TODO

public static KeyPair generateKeyPair() @ L68

• 方法名：generateKeyPair
• 源码定位：L68
• 返回类型：KeyPair
• 修饰符：public static

参数:

• 无

说明:

TODO

public static byte[] digestData(String serverId, PublicKey publicKey, SecretKey sharedKey) @ L78

• 方法名：digestData
• 源码定位：L78
• 返回类型：byte[]
• 修饰符：public static

参数:

• serverId: String
• publicKey: PublicKey
• sharedKey: SecretKey

说明:

TODO

private static byte[] digestData(byte[]... inputs) @ L86

• 方法名：digestData
• 源码定位：L86
• 返回类型：byte[]
• 修饰符：private static

参数:

• inputs: byte[]…

说明:

TODO

private static <T extends Key> T rsaStringToKey(String input, String header, String footer, Crypt.ByteArrayToKeyFunction<T> byteArrayToKey) @ L96

• 方法名：rsaStringToKey
• 源码定位：L96
• 返回类型： T
• 修饰符：private static

参数:

• input: String
• header: String
• footer: String
• byteArrayToKey: Crypt.ByteArrayToKeyFunction

说明:

TODO

public static PrivateKey stringToPemRsaPrivateKey(String rsaString) @ L111

• 方法名：stringToPemRsaPrivateKey
• 源码定位：L111
• 返回类型：PrivateKey
• 修饰符：public static

参数:

• rsaString: String

说明:

TODO

public static PublicKey stringToRsaPublicKey(String rsaString) @ L115

• 方法名：stringToRsaPublicKey
• 源码定位：L115
• 返回类型：PublicKey
• 修饰符：public static

参数:

• rsaString: String

说明:

TODO

public static String rsaPublicKeyToString(PublicKey publicKey) @ L119

• 方法名：rsaPublicKeyToString
• 源码定位：L119
• 返回类型：String
• 修饰符：public static

参数:

• publicKey: PublicKey

说明:

TODO

public static String pemRsaPrivateKeyToString(PrivateKey privateKey) @ L127

• 方法名：pemRsaPrivateKeyToString
• 源码定位：L127
• 返回类型：String
• 修饰符：public static

参数:

• privateKey: PrivateKey

说明:

TODO

private static PrivateKey byteToPrivateKey(byte[] keyData) @ L135

• 方法名：byteToPrivateKey
• 源码定位：L135
• 返回类型：PrivateKey
• 修饰符：private static

参数:

• keyData: byte[]

说明:

TODO

public static PublicKey byteToPublicKey(byte[] keyData) @ L145

• 方法名：byteToPublicKey
• 源码定位：L145
• 返回类型：PublicKey
• 修饰符：public static

参数:

• keyData: byte[]

说明:

TODO

public static SecretKey decryptByteToSecretKey(PrivateKey privateKey, byte[] keyData) @ L155

• 方法名：decryptByteToSecretKey
• 源码定位：L155
• 返回类型：SecretKey
• 修饰符：public static

参数:

• privateKey: PrivateKey
• keyData: byte[]

说明:

TODO

public static byte[] encryptUsingKey(Key key, byte[] input) @ L165

• 方法名：encryptUsingKey
• 源码定位：L165
• 返回类型：byte[]
• 修饰符：public static

参数:

• key: Key
• input: byte[]

说明:

TODO

public static byte[] decryptUsingKey(Key key, byte[] input) @ L169

• 方法名：decryptUsingKey
• 源码定位：L169
• 返回类型：byte[]
• 修饰符：public static

参数:

• key: Key
• input: byte[]

说明:

TODO

private static byte[] cipherData(int cipherOpMode, Key key, byte[] input) @ L173

• 方法名：cipherData
• 源码定位：L173
• 返回类型：byte[]
• 修饰符：private static

参数:

• cipherOpMode: int
• key: Key
• input: byte[]

说明:

TODO

private static Cipher setupCipher(int cipherOpMode, String algorithm, Key key) @ L181

• 方法名：setupCipher
• 源码定位：L181
• 返回类型：Cipher
• 修饰符：private static

参数:

• cipherOpMode: int
• algorithm: String
• key: Key

说明:

TODO

public static Cipher getCipher(int opMode, Key key) @ L187

• 方法名：getCipher
• 源码定位：L187
• 返回类型：Cipher
• 修饰符：public static

参数:

• opMode: int
• key: Key

说明:

TODO

代码

public class Crypt {
    private static final String SYMMETRIC_ALGORITHM = "AES";
    private static final int SYMMETRIC_BITS = 128;
    private static final String ASYMMETRIC_ALGORITHM = "RSA";
    private static final int ASYMMETRIC_BITS = 1024;
    private static final String BYTE_ENCODING = "ISO_8859_1";
    private static final String HASH_ALGORITHM = "SHA-1";
    public static final String SIGNING_ALGORITHM = "SHA256withRSA";
    public static final int SIGNATURE_BYTES = 256;
    private static final String PEM_RSA_PRIVATE_KEY_HEADER = "-----BEGIN RSA PRIVATE KEY-----";
    private static final String PEM_RSA_PRIVATE_KEY_FOOTER = "-----END RSA PRIVATE KEY-----";
    public static final String RSA_PUBLIC_KEY_HEADER = "-----BEGIN RSA PUBLIC KEY-----";
    private static final String RSA_PUBLIC_KEY_FOOTER = "-----END RSA PUBLIC KEY-----";
    public static final String MIME_LINE_SEPARATOR = "\n";
    public static final Encoder MIME_ENCODER = Base64.getMimeEncoder(76, "\n".getBytes(StandardCharsets.UTF_8));
    public static final Codec<PublicKey> PUBLIC_KEY_CODEC = Codec.STRING.comapFlatMap(rsaString -> {
        try {
            return DataResult.success(stringToRsaPublicKey(rsaString));
        } catch (CryptException var2) {
            return DataResult.error(var2::getMessage);
        }
    }, Crypt::rsaPublicKeyToString);
    public static final Codec<PrivateKey> PRIVATE_KEY_CODEC = Codec.STRING.comapFlatMap(rsaString -> {
        try {
            return DataResult.success(stringToPemRsaPrivateKey(rsaString));
        } catch (CryptException var2) {
            return DataResult.error(var2::getMessage);
        }
    }, Crypt::pemRsaPrivateKeyToString);
 
    public static SecretKey generateSecretKey() throws CryptException {
        try {
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            keyGenerator.init(128);
            return keyGenerator.generateKey();
        } catch (Exception var1) {
            throw new CryptException(var1);
        }
    }
 
    public static KeyPair generateKeyPair() throws CryptException {
        try {
            KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
            generator.initialize(1024);
            return generator.generateKeyPair();
        } catch (Exception var1) {
            throw new CryptException(var1);
        }
    }
 
    public static byte[] digestData(String serverId, PublicKey publicKey, SecretKey sharedKey) throws CryptException {
        try {
            return digestData(serverId.getBytes("ISO_8859_1"), sharedKey.getEncoded(), publicKey.getEncoded());
        } catch (Exception var4) {
            throw new CryptException(var4);
        }
    }
 
    private static byte[] digestData(byte[]... inputs) throws Exception {
        MessageDigest messageDigest = MessageDigest.getInstance("SHA-1");
 
        for (byte[] input : inputs) {
            messageDigest.update(input);
        }
 
        return messageDigest.digest();
    }
 
    private static <T extends Key> T rsaStringToKey(String input, String header, String footer, Crypt.ByteArrayToKeyFunction<T> byteArrayToKey) throws CryptException {
        int begin = input.indexOf(header);
        if (begin != -1) {
            begin += header.length();
            int end = input.indexOf(footer, begin);
            input = input.substring(begin, end + 1);
        }
 
        try {
            return byteArrayToKey.apply(Base64.getMimeDecoder().decode(input));
        } catch (IllegalArgumentException var6) {
            throw new CryptException(var6);
        }
    }
 
    public static PrivateKey stringToPemRsaPrivateKey(String rsaString) throws CryptException {
        return rsaStringToKey(rsaString, "-----BEGIN RSA PRIVATE KEY-----", "-----END RSA PRIVATE KEY-----", Crypt::byteToPrivateKey);
    }
 
    public static PublicKey stringToRsaPublicKey(String rsaString) throws CryptException {
        return rsaStringToKey(rsaString, "-----BEGIN RSA PUBLIC KEY-----", "-----END RSA PUBLIC KEY-----", Crypt::byteToPublicKey);
    }
 
    public static String rsaPublicKeyToString(PublicKey publicKey) {
        if (!"RSA".equals(publicKey.getAlgorithm())) {
            throw new IllegalArgumentException("Public key must be RSA");
        } else {
            return "-----BEGIN RSA PUBLIC KEY-----\n" + MIME_ENCODER.encodeToString(publicKey.getEncoded()) + "\n-----END RSA PUBLIC KEY-----\n";
        }
    }
 
    public static String pemRsaPrivateKeyToString(PrivateKey privateKey) {
        if (!"RSA".equals(privateKey.getAlgorithm())) {
            throw new IllegalArgumentException("Private key must be RSA");
        } else {
            return "-----BEGIN RSA PRIVATE KEY-----\n" + MIME_ENCODER.encodeToString(privateKey.getEncoded()) + "\n-----END RSA PRIVATE KEY-----\n";
        }
    }
 
    private static PrivateKey byteToPrivateKey(byte[] keyData) throws CryptException {
        try {
            EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyData);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            return keyFactory.generatePrivate(keySpec);
        } catch (Exception var3) {
            throw new CryptException(var3);
        }
    }
 
    public static PublicKey byteToPublicKey(byte[] keyData) throws CryptException {
        try {
            EncodedKeySpec keySpec = new X509EncodedKeySpec(keyData);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            return keyFactory.generatePublic(keySpec);
        } catch (Exception var3) {
            throw new CryptException(var3);
        }
    }
 
    public static SecretKey decryptByteToSecretKey(PrivateKey privateKey, byte[] keyData) throws CryptException {
        byte[] key = decryptUsingKey(privateKey, keyData);
 
        try {
            return new SecretKeySpec(key, "AES");
        } catch (Exception var4) {
            throw new CryptException(var4);
        }
    }
 
    public static byte[] encryptUsingKey(Key key, byte[] input) throws CryptException {
        return cipherData(1, key, input);
    }
 
    public static byte[] decryptUsingKey(Key key, byte[] input) throws CryptException {
        return cipherData(2, key, input);
    }
 
    private static byte[] cipherData(int cipherOpMode, Key key, byte[] input) throws CryptException {
        try {
            return setupCipher(cipherOpMode, key.getAlgorithm(), key).doFinal(input);
        } catch (Exception var4) {
            throw new CryptException(var4);
        }
    }
 
    private static Cipher setupCipher(int cipherOpMode, String algorithm, Key key) throws Exception {
        Cipher cipher = Cipher.getInstance(algorithm);
        cipher.init(cipherOpMode, key);
        return cipher;
    }
 
    public static Cipher getCipher(int opMode, Key key) throws CryptException {
        try {
            Cipher cip = Cipher.getInstance("AES/CFB8/NoPadding");
            cip.init(opMode, key, new IvParameterSpec(key.getEncoded()));
            return cip;
        } catch (Exception var3) {
            throw new CryptException(var3);
        }
    }
 
    private interface ByteArrayToKeyFunction<T extends Key> {
        T apply(final byte[] input) throws CryptException;
    }
 
    public record SaltSignaturePair(long salt, byte[] signature) {
        public static final Crypt.SaltSignaturePair EMPTY = new Crypt.SaltSignaturePair(0L, ByteArrays.EMPTY_ARRAY);
 
        public SaltSignaturePair(FriendlyByteBuf input) {
            this(input.readLong(), input.readByteArray());
        }
 
        public boolean isValid() {
            return this.signature.length > 0;
        }
 
        public static void write(FriendlyByteBuf output, Crypt.SaltSignaturePair saltSignaturePair) {
            output.writeLong(saltSignaturePair.salt);
            output.writeByteArray(saltSignaturePair.signature);
        }
 
        public byte[] saltAsBytes() {
            return Longs.toByteArray(this.salt);
        }
    }
 
    public static class SaltSupplier {
        private static final SecureRandom secureRandom = new SecureRandom();
 
        public static long getLong() {
            return secureRandom.nextLong();
        }
    }
}

引用的其他类

• SignedMessageChain

  • 引用位置: 字段

• CryptException

  • 引用位置: 构造调用
  • 关联成员: CryptException()