Program: 8251
Project: 8251
Buggy source:
/** 
 * Signs and/or encrypts data based on parameters of class
 */
public PgpSignEncryptResult execute(PgpSignEncryptInputParcel input,CryptoInputParcel cryptoInput,InputData inputData,OutputStream outputStream){
  int indent=0;
  OperationLog log=new OperationLog();
  log.add(LogType.MSG_PSE,indent);
  indent+=1;
  boolean enableSignature=input.getSignatureMasterKeyId() != Constants.key.none;
  boolean enableEncryption=((input.getEncryptionMasterKeyIds() != null && input.getEncryptionMasterKeyIds().length > 0) || input.getSymmetricPassphrase() != null);
  boolean enableCompression=(input.getCompressionAlgorithm() != CompressionAlgorithmTags.UNCOMPRESSED);
  Log.d(Constants.TAG,"String_Node_Str" + enableSignature + "String_Node_Str"+ enableEncryption+ "String_Node_Str"+ enableCompression+ "String_Node_Str"+ input.isEnableAsciiArmorOutput()+ "String_Node_Str"+ input.isHiddenRecipients());
  if (enableEncryption && input.getAdditionalEncryptId() != Constants.key.none) {
    input.setEncryptionMasterKeyIds(Arrays.copyOf(input.getEncryptionMasterKeyIds(),input.getEncryptionMasterKeyIds().length + 1));
    input.getEncryptionMasterKeyIds()[input.getEncryptionMasterKeyIds().length - 1]=input.getAdditionalEncryptId();
  }
  ArmoredOutputStream armorOut=null;
  OutputStream out;
  if (input.isEnableAsciiArmorOutput()) {
    armorOut=new ArmoredOutputStream(new BufferedOutputStream(outputStream,1 << 16));
    if (input.getVersionHeader() != null) {
      armorOut.setHeader("String_Node_Str",input.getVersionHeader());
    }
    if (input.getCharset() != null) {
      armorOut.setHeader("String_Node_Str",input.getCharset());
    }
    if (input.isAddBackupHeader()) {
      armorOut.setHeader("String_Node_Str","String_Node_Str");
    }
    out=armorOut;
  }
 else {
    out=outputStream;
  }
  CanonicalizedSecretKey signingKey=null;
  if (enableSignature) {
    updateProgress(R.string.progress_extracting_signature_key,0,100);
    try {
      long signingMasterKeyId=input.getSignatureMasterKeyId();
      long signingSubKeyId=input.getSignatureSubKeyId();
{
        CanonicalizedSecretKeyRing signingKeyRing=mProviderHelper.getCanonicalizedSecretKeyRing(signingMasterKeyId);
        signingKey=signingKeyRing.getSecretKey(input.getSignatureSubKeyId());
      }
      if (!signingKey.canSign()) {
        log.add(LogType.MSG_PSE_ERROR_KEY_SIGN,indent);
        return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
      }
switch (mProviderHelper.getCachedPublicKeyRing(signingMasterKeyId).getSecretKeyType(signingSubKeyId)) {
case DIVERT_TO_CARD:
case PASSPHRASE_EMPTY:
{
          if (!signingKey.unlock(new Passphrase())) {
            throw new AssertionError("String_Node_Str" + "String_Node_Str");
          }
          break;
        }
case PIN:
case PATTERN:
case PASSPHRASE:
{
        Passphrase localPassphrase=cryptoInput.getPassphrase();
        if (localPassphrase == null) {
          try {
            localPassphrase=getCachedPassphrase(signingMasterKeyId,signingKey.getKeyId());
          }
 catch (          PassphraseCacheInterface.NoSecretKeyException ignored) {
          }
        }
        if (localPassphrase == null) {
          log.add(LogType.MSG_PSE_PENDING_PASSPHRASE,indent + 1);
          return new PgpSignEncryptResult(log,RequiredInputParcel.createRequiredSignPassphrase(signingMasterKeyId,signingKey.getKeyId(),cryptoInput.getSignatureTime()),cryptoInput);
        }
        if (!signingKey.unlock(localPassphrase)) {
          log.add(LogType.MSG_PSE_ERROR_BAD_PASSPHRASE,indent);
          return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
        }
        break;
      }
case GNU_DUMMY:
{
      log.add(LogType.MSG_PSE_ERROR_UNLOCK,indent);
      return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
    }
default :
{
    throw new AssertionError("String_Node_Str");
  }
}
}
 catch (ProviderHelper.NotFoundException e) {
log.add(LogType.MSG_PSE_ERROR_SIGN_KEY,indent);
return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
}
catch (PgpGeneralException e) {
log.add(LogType.MSG_PSE_ERROR_UNLOCK,indent);
return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
}
int requestedAlgorithm=input.getSignatureHashAlgorithm();
if (requestedAlgorithm == PgpSecurityConstants.OpenKeychainHashAlgorithmTags.USE_DEFAULT) {
input.setSignatureHashAlgorithm(PgpSecurityConstants.DEFAULT_HASH_ALGORITHM);
}
}
updateProgress(R.string.progress_preparing_streams,2,100);
PGPEncryptedDataGenerator cPk=null;
if (enableEncryption) {
int algo=input.getSymmetricEncryptionAlgorithm();
if (algo == PgpSecurityConstants.OpenKeychainSymmetricKeyAlgorithmTags.USE_DEFAULT) {
algo=PgpSecurityConstants.DEFAULT_SYMMETRIC_ALGORITHM;
}
JcePGPDataEncryptorBuilder encryptorBuilder=new JcePGPDataEncryptorBuilder(algo).setProvider(Constants.BOUNCY_CASTLE_PROVIDER_NAME).setWithIntegrityPacket(input.isIntegrityProtected());
cPk=new PGPEncryptedDataGenerator(encryptorBuilder);
if (input.getSymmetricPassphrase() != null) {
log.add(LogType.MSG_PSE_SYMMETRIC,indent);
JcePBEKeyEncryptionMethodGenerator symmetricEncryptionGenerator=new JcePBEKeyEncryptionMethodGenerator(input.getSymmetricPassphrase().getCharArray());
cPk.addMethod(symmetricEncryptionGenerator);
}
 else {
log.add(LogType.MSG_PSE_ASYMMETRIC,indent);
for (long id : input.getEncryptionMasterKeyIds()) {
try {
  CanonicalizedPublicKeyRing keyRing=mProviderHelper.getCanonicalizedPublicKeyRing(KeyRings.buildUnifiedKeyRingUri(id));
  Set<Long> encryptSubKeyIds=keyRing.getEncryptIds();
  for (  Long subKeyId : encryptSubKeyIds) {
    CanonicalizedPublicKey key=keyRing.getPublicKey(subKeyId);
    cPk.addMethod(key.getPubKeyEncryptionGenerator(input.isHiddenRecipients()));
    log.add(LogType.MSG_PSE_KEY_OK,indent + 1,KeyFormattingUtils.convertKeyIdToHex(subKeyId));
  }
  if (encryptSubKeyIds.isEmpty()) {
    log.add(LogType.MSG_PSE_KEY_WARN,indent + 1,KeyFormattingUtils.convertKeyIdToHex(id));
    if (input.isFailOnMissingEncryptionKeyIds()) {
      return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
    }
  }
}
 catch (ProviderHelper.NotFoundException e) {
  log.add(LogType.MSG_PSE_KEY_UNKNOWN,indent + 1,KeyFormattingUtils.convertKeyIdToHex(id));
  if (input.isFailOnMissingEncryptionKeyIds()) {
    return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
  }
}
}
}
}
PGPSignatureGenerator signatureGenerator=null;
if (enableSignature) {
updateProgress(R.string.progress_preparing_signature,4,100);
try {
boolean cleartext=input.isCleartextSignature() && input.isEnableAsciiArmorOutput() && !enableEncryption;
signatureGenerator=signingKey.getDataSignatureGenerator(input.getSignatureHashAlgorithm(),cleartext,cryptoInput.getCryptoData(),cryptoInput.getSignatureTime());
}
 catch (PgpGeneralException e) {
log.add(LogType.MSG_PSE_ERROR_NFC,indent);
return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
}
}
ProgressScaler progressScaler=new ProgressScaler(mProgressable,8,95,100);
PGPCompressedDataGenerator compressGen=null;
OutputStream pOut;
OutputStream encryptionOut=null;
BCPGOutputStream bcpgOut;
ByteArrayOutputStream detachedByteOut=null;
ArmoredOutputStream detachedArmorOut=null;
BCPGOutputStream detachedBcpgOut=null;
long opTime, startTime=System.currentTimeMillis();
try {
if (enableEncryption) {
updateProgress(R.string.progress_encrypting,8,100);
log.add(enableSignature ? LogType.MSG_PSE_SIGCRYPTING : LogType.MSG_PSE_ENCRYPTING,indent);
indent+=1;
encryptionOut=cPk.open(out,new byte[1 << 16]);
if (enableCompression) {
log.add(LogType.MSG_PSE_COMPRESSING,indent);
int algo=input.getCompressionAlgorithm();
if (algo == PgpSecurityConstants.OpenKeychainCompressionAlgorithmTags.USE_DEFAULT) {
  algo=PgpSecurityConstants.DEFAULT_COMPRESSION_ALGORITHM;
}
compressGen=new PGPCompressedDataGenerator(algo);
bcpgOut=new BCPGOutputStream(compressGen.open(encryptionOut));
}
 else {
bcpgOut=new BCPGOutputStream(encryptionOut);
}
if (enableSignature) {
signatureGenerator.generateOnePassVersion(false).encode(bcpgOut);
}
PGPLiteralDataGenerator literalGen=new PGPLiteralDataGenerator();
char literalDataFormatTag;
if (input.isCleartextSignature()) {
literalDataFormatTag=PGPLiteralData.UTF8;
}
 else {
literalDataFormatTag=PGPLiteralData.BINARY;
}
pOut=literalGen.open(bcpgOut,literalDataFormatTag,inputData.getOriginalFilename(),new Date(),new byte[1 << 16]);
long alreadyWritten=0;
int length;
byte[] buffer=new byte[1 << 16];
InputStream in=new BufferedInputStream(inputData.getInputStream());
while ((length=in.read(buffer)) > 0) {
pOut.write(buffer,0,length);
if (enableSignature) {
  signatureGenerator.update(buffer,0,length);
}
alreadyWritten+=length;
if (inputData.getSize() > 0) {
  long progress=100 * alreadyWritten / inputData.getSize();
  progressScaler.setProgress((int)progress,100);
}
}
literalGen.close();
indent-=1;
}
 else if (enableSignature && input.isCleartextSignature() && input.isEnableAsciiArmorOutput()) {
updateProgress(R.string.progress_signing,8,100);
log.add(LogType.MSG_PSE_SIGNING_CLEARTEXT,indent);
armorOut.beginClearText(input.getSignatureHashAlgorithm());
InputStream in=new BufferedInputStream(inputData.getInputStream());
final BufferedReader reader=new BufferedReader(new InputStreamReader(in));
processLine(reader.readLine(),armorOut,signatureGenerator);
while (true) {
String line=reader.readLine();
if (line == null) {
  armorOut.write(NEW_LINE);
  break;
}
armorOut.write(NEW_LINE);
signatureGenerator.update(NEW_LINE);
processLine(line,armorOut,signatureGenerator);
}
armorOut.endClearText();
pOut=new BCPGOutputStream(armorOut);
}
 else if (enableSignature && input.isDetachedSignature()) {
updateProgress(R.string.progress_signing,8,100);
log.add(LogType.MSG_PSE_SIGNING_DETACHED,indent);
InputStream in=new BufferedInputStream(inputData.getInputStream());
detachedByteOut=new ByteArrayOutputStream();
OutputStream detachedOut=detachedByteOut;
if (input.isEnableAsciiArmorOutput()) {
detachedArmorOut=new ArmoredOutputStream(new BufferedOutputStream(detachedOut,1 << 16));
if (input.getVersionHeader() != null) {
  detachedArmorOut.setHeader("String_Node_Str",input.getVersionHeader());
}
detachedOut=detachedArmorOut;
}
detachedBcpgOut=new BCPGOutputStream(detachedOut);
long alreadyWritten=0;
int length;
byte[] buffer=new byte[1 << 16];
while ((length=in.read(buffer)) > 0) {
signatureGenerator.update(buffer,0,length);
alreadyWritten+=length;
if (inputData.getSize() > 0) {
  long progress=100 * alreadyWritten / inputData.getSize();
  progressScaler.setProgress((int)progress,100);
}
}
pOut=null;
}
 else if (enableSignature && !input.isCleartextSignature() && !input.isDetachedSignature()) {
updateProgress(R.string.progress_signing,8,100);
log.add(LogType.MSG_PSE_SIGNING,indent);
InputStream in=new BufferedInputStream(inputData.getInputStream());
if (enableCompression) {
int algo=input.getCompressionAlgorithm();
if (algo == PgpSecurityConstants.OpenKeychainCompressionAlgorithmTags.USE_DEFAULT) {
  algo=PgpSecurityConstants.DEFAULT_COMPRESSION_ALGORITHM;
}
compressGen=new PGPCompressedDataGenerator(algo);
bcpgOut=new BCPGOutputStream(compressGen.open(out));
}
 else {
bcpgOut=new BCPGOutputStream(out);
}
signatureGenerator.generateOnePassVersion(false).encode(bcpgOut);
PGPLiteralDataGenerator literalGen=new PGPLiteralDataGenerator();
pOut=literalGen.open(bcpgOut,PGPLiteralData.BINARY,inputData.getOriginalFilename(),new Date(),new byte[1 << 16]);
long alreadyWritten=0;
int length;
byte[] buffer=new byte[1 << 16];
while ((length=in.read(buffer)) > 0) {
pOut.write(buffer,0,length);
signatureGenerator.update(buffer,0,length);
alreadyWritten+=length;
if (inputData.getSize() > 0) {
  long progress=100 * alreadyWritten / inputData.getSize();
  progressScaler.setProgress((int)progress,100);
}
}
literalGen.close();
}
 else {
throw new AssertionError("String_Node_Str");
}
if (enableSignature) {
updateProgress(R.string.progress_generating_signature,95,100);
try {
if (detachedBcpgOut != null) {
  signatureGenerator.generate().encode(detachedBcpgOut);
}
 else {
  signatureGenerator.generate().encode(pOut);
}
}
 catch (NfcSyncPGPContentSignerBuilder.NfcInteractionNeeded e) {
log.add(LogType.MSG_PSE_PENDING_NFC,indent);
return new PgpSignEncryptResult(log,RequiredInputParcel.createNfcSignOperation(signingKey.getRing().getMasterKeyId(),signingKey.getKeyId(),e.hashToSign,e.hashAlgo,cryptoInput.getSignatureTime()),cryptoInput);
}
}
opTime=System.currentTimeMillis() - startTime;
Log.d(Constants.TAG,"String_Node_Str" + String.format("String_Node_Str",opTime / 1000.0) + "String_Node_Str");
if (encryptionOut != null) {
if (compressGen != null) {
compressGen.close();
}
encryptionOut.close();
}
if (armorOut != null) {
armorOut.close();
}
if (detachedArmorOut != null) {
detachedArmorOut.close();
}
if (detachedByteOut != null) {
detachedByteOut.close();
}
if (out != null) {
out.close();
}
if (outputStream != null) {
outputStream.close();
}
}
 catch (SignatureException e) {
log.add(LogType.MSG_PSE_ERROR_SIG,indent);
return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
}
catch (PGPException e) {
log.add(LogType.MSG_PSE_ERROR_PGP,indent);
return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
}
catch (IOException e) {
log.add(LogType.MSG_PSE_ERROR_IO,indent);
return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
}
updateProgress(R.string.progress_done,100,100);
log.add(LogType.MSG_PSE_OK,indent);
PgpSignEncryptResult result=new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_OK,log);
result.mOperationTime=opTime;
if (detachedByteOut != null) {
try {
detachedByteOut.flush();
detachedByteOut.close();
}
 catch (IOException e) {
}
result.setDetachedSignature(detachedByteOut.toByteArray());
try {
String digestName=PGPUtil.getDigestName(input.getSignatureHashAlgorithm());
result.setMicAlgDigestName("String_Node_Str" + digestName.toLowerCase());
}
 catch (PGPException e) {
Log.e(Constants.TAG,"String_Node_Str",e);
}
}
return result;
}

Fixed version (ground truth):
/** 
 * Signs and/or encrypts data based on parameters of class
 */
public PgpSignEncryptResult execute(PgpSignEncryptInputParcel input,CryptoInputParcel cryptoInput,InputData inputData,OutputStream outputStream){
  int indent=0;
  OperationLog log=new OperationLog();
  log.add(LogType.MSG_PSE,indent);
  indent+=1;
  boolean enableSignature=input.getSignatureMasterKeyId() != Constants.key.none;
  boolean enableEncryption=((input.getEncryptionMasterKeyIds() != null && input.getEncryptionMasterKeyIds().length > 0) || input.getSymmetricPassphrase() != null);
  boolean enableCompression=(input.getCompressionAlgorithm() != CompressionAlgorithmTags.UNCOMPRESSED);
  Log.d(Constants.TAG,"String_Node_Str" + enableSignature + "String_Node_Str"+ enableEncryption+ "String_Node_Str"+ enableCompression+ "String_Node_Str"+ input.isEnableAsciiArmorOutput()+ "String_Node_Str"+ input.isHiddenRecipients());
  if (enableEncryption && input.getAdditionalEncryptId() != Constants.key.none) {
    input.setEncryptionMasterKeyIds(Arrays.copyOf(input.getEncryptionMasterKeyIds(),input.getEncryptionMasterKeyIds().length + 1));
    input.getEncryptionMasterKeyIds()[input.getEncryptionMasterKeyIds().length - 1]=input.getAdditionalEncryptId();
  }
  ArmoredOutputStream armorOut=null;
  OutputStream out;
  if (input.isEnableAsciiArmorOutput()) {
    armorOut=new ArmoredOutputStream(new BufferedOutputStream(outputStream,1 << 16));
    if (input.getVersionHeader() != null) {
      armorOut.setHeader("String_Node_Str",input.getVersionHeader());
    }
    if (input.getCharset() != null) {
      armorOut.setHeader("String_Node_Str",input.getCharset());
    }
    if (input.isAddBackupHeader()) {
      armorOut.setHeader("String_Node_Str","String_Node_Str");
    }
    out=armorOut;
  }
 else {
    out=outputStream;
  }
  CanonicalizedSecretKey signingKey=null;
  if (enableSignature) {
    updateProgress(R.string.progress_extracting_signature_key,0,100);
    try {
      long signingMasterKeyId=input.getSignatureMasterKeyId();
      long signingSubKeyId=input.getSignatureSubKeyId();
      CanonicalizedSecretKeyRing signingKeyRing=mProviderHelper.getCanonicalizedSecretKeyRing(signingMasterKeyId);
      signingKey=signingKeyRing.getSecretKey(input.getSignatureSubKeyId());
      if (signingKeyRing.isExpired() || signingKeyRing.isRevoked() || signingKey.isExpired()|| signingKey.isRevoked()) {
        log.add(LogType.MSG_PSE_ERROR_REVOKED_OR_EXPIRED,indent);
        return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
      }
      if (!signingKey.canSign()) {
        log.add(LogType.MSG_PSE_ERROR_KEY_SIGN,indent);
        return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
      }
switch (mProviderHelper.getCachedPublicKeyRing(signingMasterKeyId).getSecretKeyType(signingSubKeyId)) {
case DIVERT_TO_CARD:
case PASSPHRASE_EMPTY:
{
          if (!signingKey.unlock(new Passphrase())) {
            throw new AssertionError("String_Node_Str" + "String_Node_Str");
          }
          break;
        }
case PIN:
case PATTERN:
case PASSPHRASE:
{
        Passphrase localPassphrase=cryptoInput.getPassphrase();
        if (localPassphrase == null) {
          try {
            localPassphrase=getCachedPassphrase(signingMasterKeyId,signingKey.getKeyId());
          }
 catch (          PassphraseCacheInterface.NoSecretKeyException ignored) {
          }
        }
        if (localPassphrase == null) {
          log.add(LogType.MSG_PSE_PENDING_PASSPHRASE,indent + 1);
          return new PgpSignEncryptResult(log,RequiredInputParcel.createRequiredSignPassphrase(signingMasterKeyId,signingKey.getKeyId(),cryptoInput.getSignatureTime()),cryptoInput);
        }
        if (!signingKey.unlock(localPassphrase)) {
          log.add(LogType.MSG_PSE_ERROR_BAD_PASSPHRASE,indent);
          return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
        }
        break;
      }
case GNU_DUMMY:
{
      log.add(LogType.MSG_PSE_ERROR_UNLOCK,indent);
      return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
    }
default :
{
    throw new AssertionError("String_Node_Str");
  }
}
}
 catch (ProviderHelper.NotFoundException e) {
log.add(LogType.MSG_PSE_ERROR_SIGN_KEY,indent);
return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
}
catch (PgpGeneralException e) {
log.add(LogType.MSG_PSE_ERROR_UNLOCK,indent);
return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
}
int requestedAlgorithm=input.getSignatureHashAlgorithm();
if (requestedAlgorithm == PgpSecurityConstants.OpenKeychainHashAlgorithmTags.USE_DEFAULT) {
input.setSignatureHashAlgorithm(PgpSecurityConstants.DEFAULT_HASH_ALGORITHM);
}
}
updateProgress(R.string.progress_preparing_streams,2,100);
PGPEncryptedDataGenerator cPk=null;
if (enableEncryption) {
int algo=input.getSymmetricEncryptionAlgorithm();
if (algo == PgpSecurityConstants.OpenKeychainSymmetricKeyAlgorithmTags.USE_DEFAULT) {
algo=PgpSecurityConstants.DEFAULT_SYMMETRIC_ALGORITHM;
}
JcePGPDataEncryptorBuilder encryptorBuilder=new JcePGPDataEncryptorBuilder(algo).setProvider(Constants.BOUNCY_CASTLE_PROVIDER_NAME).setWithIntegrityPacket(input.isIntegrityProtected());
cPk=new PGPEncryptedDataGenerator(encryptorBuilder);
if (input.getSymmetricPassphrase() != null) {
log.add(LogType.MSG_PSE_SYMMETRIC,indent);
JcePBEKeyEncryptionMethodGenerator symmetricEncryptionGenerator=new JcePBEKeyEncryptionMethodGenerator(input.getSymmetricPassphrase().getCharArray());
cPk.addMethod(symmetricEncryptionGenerator);
}
 else {
log.add(LogType.MSG_PSE_ASYMMETRIC,indent);
for (long id : input.getEncryptionMasterKeyIds()) {
try {
  CanonicalizedPublicKeyRing keyRing=mProviderHelper.getCanonicalizedPublicKeyRing(KeyRings.buildUnifiedKeyRingUri(id));
  Set<Long> encryptSubKeyIds=keyRing.getEncryptIds();
  for (  Long subKeyId : encryptSubKeyIds) {
    CanonicalizedPublicKey key=keyRing.getPublicKey(subKeyId);
    cPk.addMethod(key.getPubKeyEncryptionGenerator(input.isHiddenRecipients()));
    log.add(LogType.MSG_PSE_KEY_OK,indent + 1,KeyFormattingUtils.convertKeyIdToHex(subKeyId));
  }
  if (encryptSubKeyIds.isEmpty()) {
    log.add(LogType.MSG_PSE_KEY_WARN,indent + 1,KeyFormattingUtils.convertKeyIdToHex(id));
    return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
  }
  if (keyRing.isExpired() || keyRing.isRevoked()) {
    log.add(LogType.MSG_PSE_ERROR_REVOKED_OR_EXPIRED,indent);
    return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
  }
}
 catch (ProviderHelper.NotFoundException e) {
  log.add(LogType.MSG_PSE_KEY_UNKNOWN,indent + 1,KeyFormattingUtils.convertKeyIdToHex(id));
  return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
}
}
}
}
PGPSignatureGenerator signatureGenerator=null;
if (enableSignature) {
updateProgress(R.string.progress_preparing_signature,4,100);
try {
boolean cleartext=input.isCleartextSignature() && input.isEnableAsciiArmorOutput() && !enableEncryption;
signatureGenerator=signingKey.getDataSignatureGenerator(input.getSignatureHashAlgorithm(),cleartext,cryptoInput.getCryptoData(),cryptoInput.getSignatureTime());
}
 catch (PgpGeneralException e) {
log.add(LogType.MSG_PSE_ERROR_NFC,indent);
return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
}
}
ProgressScaler progressScaler=new ProgressScaler(mProgressable,8,95,100);
PGPCompressedDataGenerator compressGen=null;
OutputStream pOut;
OutputStream encryptionOut=null;
BCPGOutputStream bcpgOut;
ByteArrayOutputStream detachedByteOut=null;
ArmoredOutputStream detachedArmorOut=null;
BCPGOutputStream detachedBcpgOut=null;
long opTime, startTime=System.currentTimeMillis();
try {
if (enableEncryption) {
updateProgress(R.string.progress_encrypting,8,100);
log.add(enableSignature ? LogType.MSG_PSE_SIGCRYPTING : LogType.MSG_PSE_ENCRYPTING,indent);
indent+=1;
encryptionOut=cPk.open(out,new byte[1 << 16]);
if (enableCompression) {
log.add(LogType.MSG_PSE_COMPRESSING,indent);
int algo=input.getCompressionAlgorithm();
if (algo == PgpSecurityConstants.OpenKeychainCompressionAlgorithmTags.USE_DEFAULT) {
  algo=PgpSecurityConstants.DEFAULT_COMPRESSION_ALGORITHM;
}
compressGen=new PGPCompressedDataGenerator(algo);
bcpgOut=new BCPGOutputStream(compressGen.open(encryptionOut));
}
 else {
bcpgOut=new BCPGOutputStream(encryptionOut);
}
if (enableSignature) {
signatureGenerator.generateOnePassVersion(false).encode(bcpgOut);
}
PGPLiteralDataGenerator literalGen=new PGPLiteralDataGenerator();
char literalDataFormatTag;
if (input.isCleartextSignature()) {
literalDataFormatTag=PGPLiteralData.UTF8;
}
 else {
literalDataFormatTag=PGPLiteralData.BINARY;
}
pOut=literalGen.open(bcpgOut,literalDataFormatTag,inputData.getOriginalFilename(),new Date(),new byte[1 << 16]);
long alreadyWritten=0;
int length;
byte[] buffer=new byte[1 << 16];
InputStream in=new BufferedInputStream(inputData.getInputStream());
while ((length=in.read(buffer)) > 0) {
pOut.write(buffer,0,length);
if (enableSignature) {
  signatureGenerator.update(buffer,0,length);
}
alreadyWritten+=length;
if (inputData.getSize() > 0) {
  long progress=100 * alreadyWritten / inputData.getSize();
  progressScaler.setProgress((int)progress,100);
}
}
literalGen.close();
indent-=1;
}
 else if (enableSignature && input.isCleartextSignature() && input.isEnableAsciiArmorOutput()) {
updateProgress(R.string.progress_signing,8,100);
log.add(LogType.MSG_PSE_SIGNING_CLEARTEXT,indent);
armorOut.beginClearText(input.getSignatureHashAlgorithm());
InputStream in=new BufferedInputStream(inputData.getInputStream());
final BufferedReader reader=new BufferedReader(new InputStreamReader(in));
processLine(reader.readLine(),armorOut,signatureGenerator);
while (true) {
String line=reader.readLine();
if (line == null) {
  armorOut.write(NEW_LINE);
  break;
}
armorOut.write(NEW_LINE);
signatureGenerator.update(NEW_LINE);
processLine(line,armorOut,signatureGenerator);
}
armorOut.endClearText();
pOut=new BCPGOutputStream(armorOut);
}
 else if (enableSignature && input.isDetachedSignature()) {
updateProgress(R.string.progress_signing,8,100);
log.add(LogType.MSG_PSE_SIGNING_DETACHED,indent);
InputStream in=new BufferedInputStream(inputData.getInputStream());
detachedByteOut=new ByteArrayOutputStream();
OutputStream detachedOut=detachedByteOut;
if (input.isEnableAsciiArmorOutput()) {
detachedArmorOut=new ArmoredOutputStream(new BufferedOutputStream(detachedOut,1 << 16));
if (input.getVersionHeader() != null) {
  detachedArmorOut.setHeader("String_Node_Str",input.getVersionHeader());
}
detachedOut=detachedArmorOut;
}
detachedBcpgOut=new BCPGOutputStream(detachedOut);
long alreadyWritten=0;
int length;
byte[] buffer=new byte[1 << 16];
while ((length=in.read(buffer)) > 0) {
signatureGenerator.update(buffer,0,length);
alreadyWritten+=length;
if (inputData.getSize() > 0) {
  long progress=100 * alreadyWritten / inputData.getSize();
  progressScaler.setProgress((int)progress,100);
}
}
pOut=null;
}
 else if (enableSignature && !input.isCleartextSignature() && !input.isDetachedSignature()) {
updateProgress(R.string.progress_signing,8,100);
log.add(LogType.MSG_PSE_SIGNING,indent);
InputStream in=new BufferedInputStream(inputData.getInputStream());
if (enableCompression) {
int algo=input.getCompressionAlgorithm();
if (algo == PgpSecurityConstants.OpenKeychainCompressionAlgorithmTags.USE_DEFAULT) {
  algo=PgpSecurityConstants.DEFAULT_COMPRESSION_ALGORITHM;
}
compressGen=new PGPCompressedDataGenerator(algo);
bcpgOut=new BCPGOutputStream(compressGen.open(out));
}
 else {
bcpgOut=new BCPGOutputStream(out);
}
signatureGenerator.generateOnePassVersion(false).encode(bcpgOut);
PGPLiteralDataGenerator literalGen=new PGPLiteralDataGenerator();
pOut=literalGen.open(bcpgOut,PGPLiteralData.BINARY,inputData.getOriginalFilename(),new Date(),new byte[1 << 16]);
long alreadyWritten=0;
int length;
byte[] buffer=new byte[1 << 16];
while ((length=in.read(buffer)) > 0) {
pOut.write(buffer,0,length);
signatureGenerator.update(buffer,0,length);
alreadyWritten+=length;
if (inputData.getSize() > 0) {
  long progress=100 * alreadyWritten / inputData.getSize();
  progressScaler.setProgress((int)progress,100);
}
}
literalGen.close();
}
 else {
throw new AssertionError("String_Node_Str");
}
if (enableSignature) {
updateProgress(R.string.progress_generating_signature,95,100);
try {
if (detachedBcpgOut != null) {
  signatureGenerator.generate().encode(detachedBcpgOut);
}
 else {
  signatureGenerator.generate().encode(pOut);
}
}
 catch (NfcSyncPGPContentSignerBuilder.NfcInteractionNeeded e) {
log.add(LogType.MSG_PSE_PENDING_NFC,indent);
return new PgpSignEncryptResult(log,RequiredInputParcel.createNfcSignOperation(signingKey.getRing().getMasterKeyId(),signingKey.getKeyId(),e.hashToSign,e.hashAlgo,cryptoInput.getSignatureTime()),cryptoInput);
}
}
opTime=System.currentTimeMillis() - startTime;
Log.d(Constants.TAG,"String_Node_Str" + String.format("String_Node_Str",opTime / 1000.0) + "String_Node_Str");
if (encryptionOut != null) {
if (compressGen != null) {
compressGen.close();
}
encryptionOut.close();
}
if (armorOut != null) {
armorOut.close();
}
if (detachedArmorOut != null) {
detachedArmorOut.close();
}
if (detachedByteOut != null) {
detachedByteOut.close();
}
if (out != null) {
out.close();
}
if (outputStream != null) {
outputStream.close();
}
}
 catch (SignatureException e) {
log.add(LogType.MSG_PSE_ERROR_SIG,indent);
return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
}
catch (PGPException e) {
log.add(LogType.MSG_PSE_ERROR_PGP,indent);
return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
}
catch (IOException e) {
log.add(LogType.MSG_PSE_ERROR_IO,indent);
return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR,log);
}
updateProgress(R.string.progress_done,100,100);
log.add(LogType.MSG_PSE_OK,indent);
PgpSignEncryptResult result=new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_OK,log);
result.mOperationTime=opTime;
if (detachedByteOut != null) {
try {
detachedByteOut.flush();
detachedByteOut.close();
}
 catch (IOException e) {
}
result.setDetachedSignature(detachedByteOut.toByteArray());
try {
String digestName=PGPUtil.getDigestName(input.getSignatureHashAlgorithm());
result.setMicAlgDigestName("String_Node_Str" + digestName.toLowerCase());
}
 catch (PGPException e) {
Log.e(Constants.TAG,"String_Node_Str",e);
}
}
return result;
}