Red Hat Application Migration Toolkit
package iaik.pkcs.pkcs7;
import iaik.asn1.ASN;
import iaik.asn1.ASN1Object;
import iaik.asn1.ASN1Type;
import iaik.asn1.CON_SPEC;
import iaik.asn1.CodingException;
import iaik.asn1.DerCoder;
import iaik.asn1.EncodeListener;
import iaik.asn1.INTEGER;
import iaik.asn1.OCTET_STRING;
import iaik.asn1.ObjectID;
import iaik.asn1.SEQUENCE;
import iaik.asn1.structures.AlgorithmID;
import iaik.asn1.structures.Attribute;
import iaik.pkcs.pkcs7.Content;
import iaik.pkcs.pkcs7.DigestInfo;
import iaik.pkcs.pkcs7.IssuerAndSerialNumber;
import iaik.pkcs.pkcs7.SignedAndEnvelopedData;
import iaik.pkcs.pkcs7.SignedAndEnvelopedDataStream;
import iaik.pkcs.pkcs7.d;
import iaik.utils.Util;
import java.math.BigInteger;
import java.security.GeneralSecurityException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.SignatureException;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
public class SignerInfo implements EncodeListener, ASN1Type {
// $FF: synthetic field
static Class j;
PrivateKey c;
Attribute[] b;
byte[] e;
AlgorithmID g;
Attribute[] i;
AlgorithmID h;
IssuerAndSerialNumber d;
int a = 1;
d f;
static Class a(String var0) {
try {
return Class.forName(var0);
} catch (ClassNotFoundException var2) {
throw new NoClassDefFoundError(var2.getMessage());
}
}
public String toString(boolean var1) {
StringBuffer var2 = new StringBuffer();
var2.append("Version: " + this.a + "\n");
var2.append(this.d);
var2.append("digest_algorithm: " + this.h + "\n");
var2.append("digest_encryption_algorithm: " + this.g + "\n");
if(this.e != null) {
var2.append("encrypted_digest: " + this.e.length + " Bytes [" + Util.toString(this.e, 0, 5) + "...]\n");
} else {
var2.append("encrypted_digest: yet not set\n");
}
int var3;
if(this.i != null) {
var2.append("authenticated_attributes:\n");
for(var3 = 0; var3 < this.i.length; ++var3) {
var2.append(this.i[var3].toString());
}
}
if(this.b != null) {
var2.append("unauthenticated_attributes:\n");
for(var3 = 0; var3 < this.b.length; ++var3) {
var2.append(this.b[var3].toString());
}
}
return var2.toString();
}
public String toString() {
return this.toString(false);
}
public ASN1Object toASN1Object() throws CodingException {
SEQUENCE var1 = new SEQUENCE();
try {
var1.addComponent(new INTEGER(this.a));
var1.addComponent(this.d.toASN1Object());
var1.addComponent(this.h.toASN1Object());
OCTET_STRING var2;
if(this.i != null && this.i.length > 0) {
var2 = new OCTET_STRING();
int var3 = this.i.length;
boolean var4 = false;
for(int var5 = 0; var5 < var3; ++var5) {
if(this.i[var5].getType().equals(ObjectID.messageDigest)) {
var4 = true;
break;
}
}
if(!var4) {
if(this.f instanceof Content) {
this.encodeCalled(var2, 1);
} else {
var2.addEncodeListener(this, 1);
}
this.i = (Attribute[])Util.resizeArray(this.i, var3 + 1);
this.i[var3] = new Attribute(ObjectID.messageDigest, new ASN1Object[]{var2});
}
ASN1Object var6;
if(this.a == 2) {
var6 = ASN.createSequenceOf(this.i);
var1.addComponent(new CON_SPEC(2, var6, false));
} else {
var6 = ASN.createSetOf(this.i, true);
var1.addComponent(new CON_SPEC(0, var6, true));
}
}
var1.addComponent(this.g.toASN1Object());
var2 = new OCTET_STRING();
if(this.f instanceof Content) {
this.encodeCalled(var2, 2);
} else {
var2.addEncodeListener(this, 2);
}
var1.addComponent(var2);
if(this.b != null) {
ASN1Object var8;
if(this.a == 2) {
var8 = ASN.createSequenceOf(this.b);
var1.addComponent(new CON_SPEC(3, var8, true));
} else {
var8 = ASN.createSetOf(this.b);
var1.addComponent(new CON_SPEC(1, var8, true));
}
}
return var1;
} catch (Exception var7) {
throw new CodingException(var7.toString());
}
}
public void setUnauthenticatedAttributes(Attribute[] var1) {
this.b = var1;
}
public void setEncryptedDigest(byte[] var1) {
this.e = var1;
}
public void setAuthenticatedAttributes(Attribute[] var1) {
this.i = var1;
}
public int getVersion() {
return this.a;
}
public Attribute[] getUnauthenticatedAttributes() {
return this.b;
}
public Attribute getUnauthenticatedAttribute(ObjectID var1) {
if(this.b == null) {
return null;
} else {
for(int var2 = 0; var2 < this.b.length; ++var2) {
if(this.b[var2].getType().equals(var1)) {
return this.b[var2];
}
}
return null;
}
}
public IssuerAndSerialNumber getIssuerAndSerialNumber() {
return this.d;
}
public byte[] getEncryptedDigest() {
return this.e;
}
public AlgorithmID getDigestEncryptionAlgorithm() {
return this.g;
}
public AlgorithmID getDigestAlgorithm() {
return this.h;
}
public byte[] getDigest(PublicKey var1) throws InvalidKeyException, SignatureException {
try {
Cipher var2 = Cipher.getInstance("RSA/ECB/PKCS1Padding");
var2.init(2, var1);
DigestInfo var3 = new DigestInfo(DerCoder.decode(var2.doFinal(this.e)));
if(!this.h.equals(var3.getDigestAlgorithm())) {
throw new SignatureException("Digest algorithm mismatch!");
} else {
return var3.getDigest();
}
} catch (NoSuchAlgorithmException var4) {
throw new SignatureException(var4.toString());
} catch (GeneralSecurityException var5) {
throw new SignatureException(var5.toString());
} catch (CodingException var6) {
throw new SignatureException(var6.toString());
}
}
public Attribute[] getAuthenticatedAttributes() {
return this.i;
}
public Attribute getAuthenticatedAttribute(ObjectID var1) {
if(this.i == null) {
return null;
} else {
for(int var2 = 0; var2 < this.i.length; ++var2) {
if(this.i[var2].getType().equals(var1)) {
return this.i[var2];
}
}
return null;
}
}
public void encodeCalled(ASN1Object var1, int var2) throws CodingException {
try {
switch(var2) {
case 1:
var1.setValue(this.f.getMessageDigest(this.h));
return;
case 2:
if(this.e == null) {
byte[] var3;
if(this.i == null) {
var3 = this.f.getMessageDigest(this.h);
} else {
MessageDigest var4 = MessageDigest.getInstance(this.h.getName());
if(this.a == 2) {
var3 = var4.digest(DerCoder.encode(ASN.createSequenceOf(this.i)));
} else {
var3 = var4.digest(DerCoder.encode(ASN.createSetOf(this.i, true)));
}
}
DigestInfo var11 = new DigestInfo(this.h, var3);
Cipher var5 = Cipher.getInstance("RSA/ECB/PKCS1Padding");
var5.init(1, this.c);
this.e = var5.doFinal(var11.toByteArray());
if(this.f instanceof SignedAndEnvelopedData || this.f instanceof SignedAndEnvelopedDataStream) {
AlgorithmID var6 = null;
IvParameterSpec var8;
Cipher var9;
if(this.f instanceof SignedAndEnvelopedData) {
SignedAndEnvelopedData var7 = (SignedAndEnvelopedData)this.f;
var6 = var7.c.getContentEncryptionAlgorithm();
var8 = new IvParameterSpec((byte[])var6.getParameter().getValue());
var9 = var6.getCipherInstance();
var9.init(1, var7.a, var8, (SecureRandom)null);
this.e = var9.doFinal(this.e);
} else {
SignedAndEnvelopedDataStream var12 = (SignedAndEnvelopedDataStream)this.f;
var6 = var12.c.getContentEncryptionAlgorithm();
var8 = new IvParameterSpec((byte[])var6.getParameter().getValue());
var9 = var6.getCipherInstance();
var9.init(1, var12.a, var8, (SecureRandom)null);
this.e = var9.doFinal(this.e);
}
}
}
var1.setValue(this.e);
return;
default:
}
} catch (Exception var10) {
throw new CodingException("Unable to encrypt digest: " + var10.getMessage());
}
}
public void decode(ASN1Object var1) throws CodingException {
try {
ASN1Object var2 = null;
int var3 = 0;
this.a = ((BigInteger)var1.getComponentAt(0).getValue()).intValue();
this.d = new IssuerAndSerialNumber(var1.getComponentAt(1));
this.h = new AlgorithmID(var1.getComponentAt(2));
var2 = var1.getComponentAt(3);
if(var2.isA(ASN.CON_SPEC)) {
if(this.a != 2) {
((CON_SPEC)var2).forceImplicitlyTagged(ASN.SEQUENCE);
}
this.i = (Attribute[])ASN.parseSequenceOf((ASN1Object)var2.getValue(), j != null?j:(j = a("iaik.asn1.structures.Attribute")));
++var3;
}
this.g = new AlgorithmID(var1.getComponentAt(3 + var3));
this.e = (byte[])var1.getComponentAt(4 + var3).getValue();
if(5 + var3 < var1.countComponents()) {
CON_SPEC var4 = (CON_SPEC)var1.getComponentAt(5 + var3);
var4.forceImplicitlyTagged(ASN.SEQUENCE);
this.b = (Attribute[])ASN.parseSequenceOf((ASN1Object)var4.getValue(), j != null?j:(j = a("iaik.asn1.structures.Attribute")));
}
} catch (Exception var5) {
throw new CodingException(var5.toString());
}
}
public SignerInfo(IssuerAndSerialNumber var1, AlgorithmID var2, PrivateKey var3) {
this.h = AlgorithmID.sha;
this.g = AlgorithmID.rsaEncryption;
this.d = var1;
this.h = var2;
this.c = var3;
}
public SignerInfo(IssuerAndSerialNumber var1, AlgorithmID var2, AlgorithmID var3, PrivateKey var4) {
this.h = AlgorithmID.sha;
this.g = AlgorithmID.rsaEncryption;
if(!var3.equals(AlgorithmID.rsaEncryption)) {
throw new IllegalArgumentException("Algorithm " + var3.getName() + " not supported for digest encryption!");
} else {
this.d = var1;
this.h = var2;
this.g = var3;
this.c = var4;
}
}
public SignerInfo(ASN1Object var1) throws CodingException {
this.h = AlgorithmID.sha;
this.g = AlgorithmID.rsaEncryption;
this.decode(var1);
}
public SignerInfo() {
this.h = AlgorithmID.sha;
this.g = AlgorithmID.rsaEncryption;
}
}