Java SealedObject.getObject方法代码示例

import javax.crypto.SealedObject; //导入方法依赖的package包/类
public static Serializable decryptAnDeserializeObject(final String string, final SecretKey key) {

        if (string == null) {
            throw new IllegalArgumentException("string must not be null");
        }

        try {
            final byte[] userr = BaseEncoding.base64().decode(string);
            final ByteArrayInputStream bis = new ByteArrayInputStream(userr);
            final ObjectInputStream in = new ObjectInputStream(bis);
            final SealedObject ud = (SealedObject) in.readObject();
            return (Serializable) ud.getObject(key);
        } catch (final Exception e) {
            log.error(e.toString(), e);
            throw new ElasticsearchException(e.toString());
        }
    }
 

import javax.crypto.SealedObject; //导入方法依赖的package包/类
public Collection<Ftp> readFtpHistory(Cipher cipher, String intallationPath) {

		String path = intallationPath + "/" + FTP_FOLDER;
		File directory = new File(path);
		File[] subfiles = directory.listFiles();
		Collection<Ftp> ftps = new ArrayList<Ftp>();

		for (int i = 0; i < subfiles.length; i++) {
			try {
				String ftpPath = subfiles[i].getAbsolutePath();
				ObjectInputStream fRo = new ObjectInputStream(
						new GZIPInputStream(new FileInputStream(ftpPath)));
				SealedObject sealedObject = (SealedObject) fRo.readObject();
				Ftp ftp = (Ftp) sealedObject.getObject(cipher);
				ftps.add(ftp);
				fRo.close();
			} catch (Exception e) {
				// throw new LoadingException("Can't load ftp! " +
				// e.getMessage());
				e.printStackTrace();
			}
		}
		return ftps;
	}
 

import javax.crypto.SealedObject; //导入方法依赖的package包/类
/**
 * Parses a SealedObject from the given byte array and retrieves the original wrapped object
 *
 * @param encryptedObject a byte array representing a SealedObject
 * @param maxBytes        the maximum size allowed for the read object
 * @return the original Serializable object
 * @throws CryptoOperationRuntimeException
 * @see #sealObject(java.io.Serializable) the matching wrapping operation
 */
public Object unsealObject(byte[] encryptedObject, long maxBytes) {
    try {
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(encryptedObject);
        SealedObject sealedObject = SafeObjectReader.safeReadObject(SealedObject.class, new ArrayList<>(), MAX_OBJECTS, maxBytes, byteArrayInputStream);
        return sealedObject.getObject(key);
    } catch (IOException | ClassNotFoundException | InvalidKeyException | NoSuchAlgorithmException e) {
        throw new CryptoOperationRuntimeException("cannot unseal object", e);
    }

}
 

import javax.crypto.SealedObject; //导入方法依赖的package包/类
/**
 * Unseals the specified sealed object.
 * @param object the sealed object
 * @return the unsealed object
 */
public Serializable unseal(SealedObject object) {
    try {
        Cipher cipher = Cipher.getInstance(_sealAlgorithm);
        cipher.init(Cipher.DECRYPT_MODE, _secretKey);
        return (Serializable)object.getObject(cipher);
    } catch (Exception e) {
        throw new SwitchYardException(e);
    }
}
 

import javax.crypto.SealedObject; //导入方法依赖的package包/类
public final static PrivateKey readPrivateKey(Cipher decrypt_cipher, String key_file, String algorithm) throws IOException, ClassNotFoundException, GeneralSecurityException {
	URL key_url = PasswordKey.class.getResource("/" + key_file);
	ObjectInputStream is = new ObjectInputStream(key_url.openStream());
	SealedObject sealed_key = (SealedObject)is.readObject();
	byte[] encoded_registration_key = (byte[])sealed_key.getObject(decrypt_cipher);
	return KeyManager.readPrivateKey(encoded_registration_key, algorithm);
}
 

import javax.crypto.SealedObject; //导入方法依赖的package包/类
static void testKey() throws Exception
{
   int size = 8 * 24;
   KeyGenerator kgen = KeyGenerator.getInstance("Blowfish");
   kgen.init(size);
   SecretKey key = kgen.generateKey();
   byte[] kbytes = key.getEncoded();
   System.out.println("key.Algorithm = "+key.getAlgorithm());
   System.out.println("key.Format = "+key.getFormat());
   System.out.println("key.Encoded Size = "+kbytes.length);
   
   Cipher cipher = Cipher.getInstance("Blowfish");
   AlgorithmParameters params = cipher.getParameters();
   System.out.println("Blowfish.params = "+params);
   cipher.init(Cipher.ENCRYPT_MODE, key);
   SealedObject msg = new SealedObject("This is a secret", cipher);
   
   SecretKeySpec serverKey = new SecretKeySpec(kbytes, "Blowfish");
   Cipher scipher = Cipher.getInstance("Blowfish");
   scipher.init(Cipher.DECRYPT_MODE, serverKey);
   String theMsg = (String) msg.getObject(scipher);
   System.out.println("Decrypted: "+theMsg);
   
   SecureRandom rnd = SecureRandom.getInstance("SHA1PRNG");
   BigInteger bi = new BigInteger(320, rnd);
   byte[] k2bytes = bi.toByteArray();
   SecretKeySpec keySpec = new SecretKeySpec(k2bytes, "Blowfish");
   System.out.println("key2.Algorithm = "+key.getAlgorithm());
   System.out.println("key2.Format = "+key.getFormat());
   System.out.println("key2.Encoded Size = "+kbytes.length);
   System.out.println("keySpec.Algorithm = " + keySpec.getAlgorithm());
   System.out.println("keySpec.Format = " + keySpec.getFormat());
}
 

import javax.crypto.SealedObject; //导入方法依赖的package包/类
@Override
public PublicKey recieveKey() throws Exception {
    ObjectInputStream in = new ObjectInputStream(this.in);
    SealedObject encryptedKey = (SealedObject) in.readObject();
    return (PublicKey) encryptedKey.getObject(SecretKeyFactory.getInstance("DES").translateKey(new SecretKeySpec(b, "DES")));
    
}
 

import javax.crypto.SealedObject; //导入方法依赖的package包/类
private boolean test1(Cipher c, Cipher d, String s) 
throws Exception 
{
    start = System.nanoTime();
    String rs = "";
    SealedObject so = new SealedObject(s, c);
    rs = (String)so.getObject(d);
    finish = System.nanoTime();
    return rs.equals(s);
}
 

import javax.crypto.SealedObject; //导入方法依赖的package包/类
private boolean test2(Cipher c, SecretKey sKey, String s)
throws Exception 
{
    start = System.nanoTime();
    String rs = "";
    SealedObject so = new SealedObject(s, c);
    rs = (String)so.getObject(sKey);
    finish = System.nanoTime();
    return rs.equals(s);
}
 

import javax.crypto.SealedObject; //导入方法依赖的package包/类
public Ftp readAutoConfig(Cipher cipher, String path)
		throws FileNotFoundException, IOException, ClassNotFoundException,
		NoSuchAlgorithmException, NoSuchPaddingException,
		InvalidKeyException, IllegalBlockSizeException, BadPaddingException {

	ObjectInputStream fRo = new ObjectInputStream(new GZIPInputStream(
			new FileInputStream(path)));
	SealedObject sealedObject = (SealedObject) fRo.readObject();
	Ftp ftp = (Ftp) sealedObject.getObject(cipher);
	fRo.close();
	return ftp;
}
 

import javax.crypto.SealedObject; //导入方法依赖的package包/类
public boolean runTest(Provider p, String algo, PrintStream out)
        throws Exception {

    byte[] salt = new byte[8];
    int ITERATION_COUNT = 1000;
    AlgorithmParameters pbeParams = null;

    String baseAlgo
            = new StringTokenizer(algo, "/").nextToken().toUpperCase();
    boolean isAES = baseAlgo.contains("AES");

    try {
        // Initialization
        Cipher ci = Cipher.getInstance(algo, p);
        new Random().nextBytes(salt);
        AlgorithmParameterSpec aps = new PBEParameterSpec(salt,
                ITERATION_COUNT);
        SecretKeyFactory skf = SecretKeyFactory.getInstance(baseAlgo, p);
        SecretKey key = skf.generateSecret(
                new PBEKeySpec("Secret Lover".toCharArray()));

        // Seal
        if (isAES) {
            ci.init(Cipher.ENCRYPT_MODE, key);
            pbeParams = ci.getParameters();
        } else {
            ci.init(Cipher.ENCRYPT_MODE, key, aps);
        }

        SealedObject so = new SealedObject(key, ci);

        // Unseal and compare
        if (isAES) {
            ci.init(Cipher.DECRYPT_MODE, key, pbeParams);
        } else {
            ci.init(Cipher.DECRYPT_MODE, key, aps);
        }

        SecretKey unsealedKey;

        unsealedKey = (SecretKey) so.getObject(ci);
        if (!Arrays.equals(unsealedKey.getEncoded(), key.getEncoded())) {
            return false;
        }

        unsealedKey = (SecretKey) so.getObject(key);
        if (!Arrays.equals(unsealedKey.getEncoded(), key.getEncoded())) {
            return false;
        }

        unsealedKey = (SecretKey) so.getObject(key, "SunJCE");
        return Arrays.equals(unsealedKey.getEncoded(), key.getEncoded());
    } catch (InvalidKeyException ex) {
        if (baseAlgo.endsWith("TRIPLEDES") || baseAlgo.endsWith("AES_256")) {
            out.println(
                    "Expected exception , keyStrength > 128 within" + algo);
            return true;
        }

        throw ex;
    }
}
 

import javax.crypto.SealedObject; //导入方法依赖的package包/类
public TestResult perform()
{
    try
    {
        KeyGenerator keyGen = KeyGenerator.getInstance("DES", provider);
        Key key = keyGen.generateKey();
        Cipher c = Cipher.getInstance("DES/ECB/PKCS5Padding", provider);

        c.init(Cipher.ENCRYPT_MODE, key);
        String object = "Hello world";
        SealedObject so = new SealedObject(object, c);
        c.init(Cipher.DECRYPT_MODE, key);

        Object o = so.getObject(c);
        if (!o.equals(object))
        {
            return new SimpleTestResult(false, "Result object 1 not equal"
                    + "orig: " + object + " res: " + o);
        }

        o = so.getObject(key);
        if (!o.equals(object))
        {
            return new SimpleTestResult(false, "Result object 2 not equal"
                    + "orig: " + object + " res: " + o);
        }

        o = so.getObject(key, provider);
        if (!o.equals(object))
        {
            return new SimpleTestResult(false, "Result object 3 not equal"
                    + "orig: " + object + " res: " + o);
        }

        return new SimpleTestResult(true, getName() + ": Okay");
    }
    catch (Exception e)
    {
        return new SimpleTestResult(false, getName()
                + ": failed excpetion - " + e.toString(), e);
    }
}