import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
public RsaPrivateStream()
  throws KeyczarException
{
  try
  {
    this.signature = Signature.getInstance("SHA1withRSA");
    this.verifyingStream = ((VerifyingStream)RsaPrivateKey.this.publicKey.getStream());
    this.cipher = Cipher.getInstance(RsaPrivateKey.this.publicKey.getPadding().cryptAlgorithm);
    this.encryptingStream = ((EncryptingStream)RsaPrivateKey.this.publicKey.getStream());
    return;
  }
  catch (GeneralSecurityException localGeneralSecurityException)
  {
    throw new KeyczarException(localGeneralSecurityException);
  }
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
@Test
public void testCreateExportKey() throws KeyczarException {
	// create the key, export the public key; 1024 bits is the smallest size
	GenericKeyczar keyczar = Util.createKey(
	    DefaultKeyType.RSA_PRIV, KeyPurpose.DECRYPT_AND_ENCRYPT, 1024);
	KeyczarReader publicKeyReader = Util.exportPublicKeys(keyczar);
	Encrypter encrypter = new Encrypter(publicKeyReader);

	// test that it works
	String ciphertext = encrypter.encrypt(MESSAGE);
	Crypter crypter = new Crypter(Util.readerFromKeyczar(keyczar));
	String decrypted = crypter.decrypt(ciphertext);
	assertEquals(MESSAGE, decrypted);

	// test a session
	StringBuilder longMessage = new StringBuilder("hello message ");
	while (longMessage.length() < 500) {
		longMessage.append(longMessage);
	}

	ciphertext = Util.encryptWithSession(encrypter, longMessage.toString());
	assertEquals(longMessage.toString(), Util.decryptWithSession(crypter, ciphertext));
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
@Test
public void testSimple() throws KeyczarException {
	KeyczarReader reader = new KeyczarJsonReader(JSON_KEY);
	KeyMetadata metadata = KeyMetadata.read(reader.getMetadata());
	assertEquals(0, metadata.getPrimaryVersion().getVersionNumber());
	assertEquals(KeyPurpose.DECRYPT_AND_ENCRYPT, metadata.getPurpose());
	assertEquals("Imported AES", metadata.getName());
	assertEquals(1, metadata.getVersions().size());
	assertEquals(0, metadata.getVersions().get(0).getVersionNumber());
	assertFalse(metadata.getVersions().get(0).isExportable());

	Crypter crypter = new Crypter(reader);
	String plaintext = "hello world";
	String encrypted = crypter.encrypt(plaintext);
	assertTrue(!encrypted.equals(plaintext));

	String decrypted = crypter.decrypt(encrypted);
	assertEquals(plaintext, decrypted);

	// TODO: Add an old version of a key; test decrypting with it
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
@Test
public void verifyBadSignature() throws KeyczarException {
  SecretsBundle secrets = SecretsBundle.generateForTest();

  final String TOKEN = "token";
  String signature = secrets.signToken(TOKEN);
  assertTrue(secrets.verifyToken(TOKEN, signature));
  assertFalse(secrets.verifyToken(TOKEN, signature + "A"));
  // Base64DecodingException
  assertFalse(secrets.verifyToken(TOKEN, signature.substring(0, signature.length()-1)));
  assertFalse(secrets.verifyToken(TOKEN, signature.substring(0, signature.length()-2)));
  // ArrayIndexOutOfBoundsException
  assertFalse(secrets.verifyToken(TOKEN, ""));

  // change the first byte: version exception
  assert signature.charAt(0) == 'A';
  assertFalse(secrets.verifyToken(TOKEN, 'B' + signature.substring(1, signature.length())));
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
@Override
protected MitroRPC processCommand(MitroRequestContext context)
    throws IOException, SQLException, MitroServletException {
  RPC.CheckTwoFactorRequiredRequest in = gson.fromJson(context.jsonRequest,
      RPC.CheckTwoFactorRequiredRequest.class);
  String url = null;
  // url stays null if 2fa isn't enabled. else, changes to 2fa login page
  if (context.requestor.isTwoFactorAuthEnabled()) {
    String token = GetMyPrivateKey.makeLoginTokenString(context.requestor,
        in.extensionId, in.deviceId);
    String signedToken;
    try {
      signedToken = TwoFactorSigningService.signToken(token);
    } catch (KeyczarException e) {
      throw new MitroServletException(e);
    }
    url = context.requestServerUrl + "/mitro-core/TwoFactorAuth?token="
        + URLEncoder.encode(token, "UTF-8") + "&signature="
        + URLEncoder.encode(signedToken, "UTF-8");
  }
  RPC.CheckTwoFactorRequiredResponse out = new RPC.CheckTwoFactorRequiredResponse();
  out.twoFactorUrl = url;
  return out;
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
public AesStream()
  throws KeyczarException
{
  IvParameterSpec localIvParameterSpec = new IvParameterSpec(new byte[16]);
  try
  {
    this.encryptingCipher = Cipher.getInstance(AesKey.this.mode.jceMode);
    this.encryptingCipher.init(1, AesKey.this.aesKey, localIvParameterSpec);
    this.decryptingCipher = Cipher.getInstance(AesKey.this.mode.jceMode);
    this.decryptingCipher.init(2, AesKey.this.aesKey, localIvParameterSpec);
    this.signStream = ((SigningStream)AesKey.this.hmacKey.getStream());
    return;
  }
  catch (GeneralSecurityException localGeneralSecurityException)
  {
    throw new KeyczarException(localGeneralSecurityException);
  }
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 *
 * <p>Uses Keyczar client to encrypt the byte array.
 *
 * @throws EncryptionException if any underlying component fails
 */
@Override
public byte[] encrypt(byte[] plain) throws EncryptionException {
  try {
    Crypter crypter = getCrypter();
    return crypter.encrypt(plain);
  } catch (KeyczarException e) {
    throw new EncryptionException(e);
  }
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 *
 * <p>Uses local Keyczar client to decrypt the byte array.
 *
 * @throws EncryptionException if any underlying component fails
 */
@Override
public byte[] decrypt(byte[] encrypted) throws EncryptionException {
  try {
    Crypter crypter = getCrypter();
    return crypter.decrypt(encrypted);
  } catch (KeyczarException e) {
    throw new EncryptionException(e);
  }
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
@Test(expected=DoTwoFactorAuthException.class)
public void testTwoFactorEnabledNotVerified() throws InvalidKeyException,
    NoSuchAlgorithmException, KeyczarException, SQLException, MitroServletException {
  // extension should check if 2FA is enabled, but we had a bug where this didn't happen
  testReq.encryptedPrivateKey = "some encrypted key";
  testProcessCommand(testIdentity);
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
public static void verify(String keyPath, String message, String signaturePath) throws KeyczarException {
  // Read the key, possibly decrypting using a password
  KeyczarReader reader = Util.readJsonFromPath(keyPath);
  Verifier key = new Verifier(reader);
  String signature = Util.readFile(signaturePath);

  System.out.println("verifying signature on message length " + message.length());
  if (!key.verify(message, signature)) {
    System.err.println("Signature could not be verified!\n");
    System.exit(1);
  }
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
@Test
public void testWriteKey() throws KeyczarException {
  // Create a key with zero value
  GenericKeyczar keyczar = makeKey();

  StringBuilder builder = new StringBuilder();
  JsonWriter.write(keyczar, builder);
  String serialized = builder.toString();

  String substr = "\"0\":\"{\\\"aesKeyString\\\":\\\"AAAAAAAAAA";
  assertTrue(serialized.contains(substr));
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
public final void initSign()
  throws KeyczarException
{
  try
  {
    this.signature.initSign(DsaPrivateKey.this.jcePrivateKey);
    return;
  }
  catch (GeneralSecurityException localGeneralSecurityException)
  {
    throw new KeyczarException(localGeneralSecurityException);
  }
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
public static void main(String[] arguments) throws KeyczarException {
  if (arguments.length != 1) {
    System.err.println("JsonWriter (input key path)");
    System.err.println("  Reads a key and writes to stdout as JSON");
    System.exit(1);
  }

  GenericKeyczar keyczar = new GenericKeyczar(new KeyczarFileReader(arguments[0]));
  write(keyczar, System.out);
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
public final void sign(ByteBuffer paramByteBuffer)
  throws KeyczarException
{
  try
  {
    paramByteBuffer.put(this.signature.sign());
    return;
  }
  catch (SignatureException localSignatureException)
  {
    throw new KeyczarException(localSignatureException);
  }
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
@Test
public void testDoGetIsEnabled() throws ServletException, IOException,
    InvalidKeyException, NoSuchAlgorithmException, SQLException,
    KeyczarException, CryptoError {
  MockHttpServletResponse response = testDoGet(null, false, false, false);
  assertThat(response.getOutput(), containsString("Enabled"));
  testIdentity = DBIdentity.getIdentityForUserName(manager, testIdentity.getName());
  assertTrue(testIdentity.getTwoFactorSecret() != null);
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
/**
 * Encrypts plaintext with a new session key, which is encrypted using crypter. The encrypted session
 * key and encrypted message are packed together using lenPrefixPack().
 */
public static byte[] encryptWithSession(Encrypter crypter, byte[] plaintext) throws KeyczarException {
	// Create a session crypter
	SessionCrypter session = new SessionCrypter(crypter);
	byte[] rawEncrypted = session.encrypt(plaintext);
	byte[][] input = {session.getSessionMaterial(), rawEncrypted};
	return org.keyczar.util.Util.lenPrefixPack(input);
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
public static String decryptSession(String keyPath, String inPath, String expectedMessage) throws KeyczarException {
  KeyczarReader reader = Util.readJsonFromPath(keyPath);
  String input = Util.readFile(inPath);
  String output = Util.decryptWithSession(new Crypter(reader), input);

  if (expectedMessage != null && !output.equals(expectedMessage)) {
    System.err.println("Session decryption does not match?\n" + output);
    System.exit(1);
  }
  return output;
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
@Test
public void testReadEncryptedKey() throws KeyczarException {
  KeyczarReader staticReader = new KeyczarReader() {
    @Override
    public String getKey() throws KeyczarException {
      return JSON_KEY;
    }

    @Override
    public String getKey(int version) throws KeyczarException {
      assert version == 1;
      return JSON_KEY;
    }

    @Override
    public String getMetadata() throws KeyczarException {
      return METADATA;
    }
  };

  KeyczarPBEReader encrypted = new KeyczarPBEReader(staticReader, PASSPHRASE);
  String prefix = "{\"aesKeyString\":\"oThFEDqkkLyp80hhh1QFjA\"";
  assertEquals(prefix, encrypted.getKey().substring(0, prefix.length()));

  GenericKeyczar keyczar = new GenericKeyczar(encrypted);
  assertEquals(1, keyczar.getVersions().size());
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
@Test
public void testWriteReadSymmetricKey() throws KeyczarException {
	GenericKeyczar keyczar = Util.createKey(DefaultKeyType.AES, KeyPurpose.DECRYPT_AND_ENCRYPT);

   String path = tempFolder.getRoot().getAbsolutePath() + "/out.json";
   Util.writeJsonToPath(keyczar, path);
   
   Crypter roundtripped = new Crypter(Util.readJsonFromPath(path));
	verifyKeyCompatibility(keyczar, roundtripped);
}
 

import org.keyczar.exceptions.KeyczarException; //导入依赖的package包/类
public final void initSign()
  throws KeyczarException
{
  try
  {
    this.signature.initSign(RsaPrivateKey.this.jcePrivateKey);
    return;
  }
  catch (GeneralSecurityException localGeneralSecurityException)
  {
    throw new KeyczarException(localGeneralSecurityException);
  }
}