Red Hat Application Migration Toolkit
package iaik.pkcs.pkcs12;
import iaik.asn1.ASN1Object;
import iaik.asn1.ASN1Type;
import iaik.asn1.CodingException;
import iaik.asn1.DerCoder;
import iaik.asn1.ObjectID;
import iaik.asn1.structures.AlgorithmID;
import iaik.pkcs.PKCSException;
import iaik.pkcs.PKCSParsingException;
import iaik.pkcs.pkcs12.PKCS8ShroudedKeyBag;
import iaik.pkcs.pkcs12.SafeBag;
import iaik.pkcs.pkcs7.ContentInfo;
import iaik.pkcs.pkcs7.Data;
import iaik.pkcs.pkcs7.EncryptedContentInfo;
import iaik.pkcs.pkcs7.EncryptedData;
import iaik.security.cipher.PBEKeyBMP;
import iaik.utils.InternalErrorException;
import java.security.AlgorithmParameters;
import java.security.GeneralSecurityException;
import java.security.InvalidAlgorithmParameterException;
import java.security.KeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.AlgorithmParameterSpec;
public class AuthenticatedSafe implements ASN1Type {
// $FF: synthetic field
static Class g;
private static final int h = 1024;
SafeBag[] a;
private int b;
private ContentInfo d;
EncryptedContentInfo c;
public static final int PUBLIC_KEY_ENCRYPTED = 3;
public static final int PASSWORD_ENCRYPTED = 2;
public static final int UNENCRYPTED = 1;
private static final boolean e = false;
private static final boolean f = false;
static Class a(String var0) {
try {
return Class.forName(var0);
} catch (ClassNotFoundException var2) {
throw new NoClassDefFoundError(var2.getMessage());
}
}
public String toString() {
StringBuffer var1 = new StringBuffer();
var1.append("mode: ");
switch(this.b) {
case 1:
var1.append("UNENCRYPTED\n");
break;
case 2:
var1.append("PASSWORD_ENCRYPTED\n");
var1.append("Content encrypted with: " + this.c.getContentEncryptionAlgorithm().getName() + "\n");
break;
case 3:
var1.append("PUBLIC_KEY_ENCRYPTED\n");
}
if(this.a == null) {
var1.append("No SafeBags or not decrypted yet.\n");
} else {
for(int var2 = 0; var2 < this.a.length; ++var2) {
var1.append("\nSafeBag: " + var2 + "\n");
var1.append(this.a[var2].toString());
}
}
return var1.toString();
}
public ASN1Object toASN1Object() throws CodingException {
try {
return this.d.toASN1Object();
} catch (PKCSException var2) {
throw new CodingException(var2.toString());
}
}
public SafeBag[] getSafeBags() {
return this.a;
}
public void encrypt(char[] var1, AlgorithmID var2) throws PKCSException, NoSuchAlgorithmException {
switch(this.b) {
case 1:
return;
case 2:
AlgorithmParameterSpec var3 = null;
if(!var2.equals(AlgorithmID.pbeWithSHAAnd40BitRC2_CBC) && !var2.equals(AlgorithmID.pbeWithSHAAnd3_KeyTripleDES_CBC)) {
throw new NoSuchAlgorithmException(var2.getName() + " not allowed!");
} else {
try {
AlgorithmParameters var4 = var2.getAlgorithmParameters("PBE");
var3 = var4.getParameterSpec(g != null?g:(g = a("javax.crypto.spec.PBEParameterSpec")));
} catch (Exception var7) {
throw new InternalErrorException(var7);
}
try {
this.c.setupCipher(var2, new PBEKeyBMP(var1), var3);
} catch (KeyException var5) {
throw new PKCSException(var5.toString());
} catch (InvalidAlgorithmParameterException var6) {
throw new PKCSException(var6.toString());
}
EncryptedData var8 = new EncryptedData(this.c);
var8.setBlockSize(1024);
this.d = new ContentInfo(var8);
return;
}
case 3:
throw new RuntimeException("PUBLIC_KEY_ENCRYPTED not implemented");
default:
throw new PKCSException("Unknown mode!");
}
}
public void decrypt(char[] var1) throws NoSuchAlgorithmException, PKCSException {
switch(this.b) {
case 1:
break;
case 2:
try {
AlgorithmID var2 = this.c.getContentEncryptionAlgorithm();
AlgorithmParameters var3 = var2.getAlgorithmParameters("PBE");
AlgorithmParameterSpec var4 = var3.getParameterSpec(g != null?g:(g = a("javax.crypto.spec.PBEParameterSpec")));
this.c.setupCipher(new PBEKeyBMP(var1), var4);
byte[] var5 = this.c.getContent();
ASN1Object var6 = DerCoder.decode(var5);
this.a = SafeBag.parseSafeContents(DerCoder.encode(var6));
break;
} catch (Exception var8) {
throw new PKCSException(var8.toString());
}
case 3:
throw new PKCSException("privacy mode PUBLIC_KEY_ENCRYPTED not implemented.");
default:
throw new PKCSException("Unknown authenticated safes mode.");
}
if(this.a != null) {
for(int var9 = 0; var9 < this.a.length; ++var9) {
if(this.a[var9] instanceof PKCS8ShroudedKeyBag) {
try {
((PKCS8ShroudedKeyBag)this.a[var9]).decrypt(var1);
} catch (GeneralSecurityException var7) {
throw new PKCSException("Unable to decrypt PrivateKey!");
}
}
}
}
}
public void decode(ASN1Object var1) throws CodingException {
try {
this.d = new ContentInfo(var1);
} catch (PKCSParsingException var3) {
throw new CodingException(var3.toString());
}
if(this.d.getContentType().equals(ObjectID.pkcs7_encryptedData)) {
this.b = 2;
EncryptedData var4 = (EncryptedData)this.d.getContent();
this.c = (EncryptedContentInfo)var4.getEncryptedContentInfo();
} else if(this.d.getContentType().equals(ObjectID.pkcs7_envelopedData)) {
this.b = 3;
throw new CodingException("public-key encrypted not implemented.");
} else if(this.d.getContentType().equals(ObjectID.pkcs7_data)) {
this.b = 1;
byte[] var2 = ((Data)this.d.getContent()).getData();
this.a = SafeBag.parseSafeContents(var2);
} else {
throw new CodingException("Unknown content type in AuthenticatedSafes.");
}
}
public AuthenticatedSafe(ASN1Object var1) throws PKCSParsingException {
try {
this.decode(var1);
} catch (CodingException var3) {
throw new PKCSParsingException(var3.toString());
}
}
public AuthenticatedSafe(int var1, SafeBag[] var2) throws PKCSException {
this.b = var1;
this.a = var2;
try {
byte[] var3 = SafeBag.encodeSafeContents(this.a);
if(var1 == 2) {
this.c = new EncryptedContentInfo(ObjectID.pkcs7_data, var3);
this.c.setBlockSize(1024);
} else if(var1 == 3) {
throw new RuntimeException("PUBLIC_KEY_ENCRYPTED not implemented");
} else if(var1 == 1) {
Data var4 = new Data(var3);
var4.setBlockSize(1024);
this.d = new ContentInfo(var4);
} else {
throw new PKCSException("Unknown mode!");
}
} catch (CodingException var5) {
throw new PKCSException("Unknown mode!");
}
}
}