1 files changed, 164 insertions, 0 deletions
diff --git a/core/src/main/java/org/spongycastle/asn1/crmf/EncryptedValue.java b/core/src/main/java/org/spongycastle/asn1/crmf/EncryptedValue.java
new file mode 100644
index 00000000..6191e3dc
--- /dev/null
+++ b/core/src/main/java/org/spongycastle/asn1/crmf/EncryptedValue.java
@@ -0,0 +1,164 @@
+package org.spongycastle.asn1.crmf;
+
+import org.spongycastle.asn1.ASN1Encodable;
+import org.spongycastle.asn1.ASN1EncodableVector;
+import org.spongycastle.asn1.ASN1Object;
+import org.spongycastle.asn1.ASN1OctetString;
+import org.spongycastle.asn1.ASN1Primitive;
+import org.spongycastle.asn1.ASN1Sequence;
+import org.spongycastle.asn1.ASN1TaggedObject;
+import org.spongycastle.asn1.DERBitString;
+import org.spongycastle.asn1.DERSequence;
+import org.spongycastle.asn1.DERTaggedObject;
+import org.spongycastle.asn1.x509.AlgorithmIdentifier;
+
+public class EncryptedValue
+    extends ASN1Object
+{
+    private AlgorithmIdentifier intendedAlg;
+    private AlgorithmIdentifier symmAlg;
+    private DERBitString        encSymmKey;
+    private AlgorithmIdentifier keyAlg;
+    private ASN1OctetString     valueHint;
+    private DERBitString        encValue;
+
+    private EncryptedValue(ASN1Sequence seq)
+    {
+        int index = 0;
+        while (seq.getObjectAt(index) instanceof ASN1TaggedObject)
+        {
+            ASN1TaggedObject tObj = (ASN1TaggedObject)seq.getObjectAt(index);
+
+            switch (tObj.getTagNo())
+            {
+            case 0:
+                intendedAlg = AlgorithmIdentifier.getInstance(tObj, false);
+                break;
+            case 1:
+                symmAlg = AlgorithmIdentifier.getInstance(tObj, false);
+                break;
+            case 2:
+                encSymmKey = DERBitString.getInstance(tObj, false);
+                break;
+            case 3:
+                keyAlg = AlgorithmIdentifier.getInstance(tObj, false);
+                break;
+            case 4:
+                valueHint = ASN1OctetString.getInstance(tObj, false);
+                break;
+            }
+            index++;
+        }
+
+        encValue = DERBitString.getInstance(seq.getObjectAt(index));
+    }
+
+    public static EncryptedValue getInstance(Object o)
+    {
+        if (o instanceof EncryptedValue)
+        {
+            return (EncryptedValue)o;
+        }
+        else if (o != null)
+        {
+            return new EncryptedValue(ASN1Sequence.getInstance(o));
+        }
+
+        return null;
+    }
+
+    public EncryptedValue(
+        AlgorithmIdentifier intendedAlg,
+        AlgorithmIdentifier symmAlg,
+        DERBitString encSymmKey,
+        AlgorithmIdentifier keyAlg,
+        ASN1OctetString valueHint,
+        DERBitString encValue)
+    {
+        if (encValue == null)
+        {
+            throw new IllegalArgumentException("'encValue' cannot be null");
+        }
+
+        this.intendedAlg = intendedAlg;
+        this.symmAlg = symmAlg;
+        this.encSymmKey = encSymmKey;
+        this.keyAlg = keyAlg;
+        this.valueHint = valueHint;
+        this.encValue = encValue;
+    }
+
+    public AlgorithmIdentifier getIntendedAlg()
+    {
+        return intendedAlg;
+    }
+
+    public AlgorithmIdentifier getSymmAlg()
+    {
+        return symmAlg;
+    }
+
+    public DERBitString getEncSymmKey()
+    {
+        return encSymmKey;
+    }
+
+    public AlgorithmIdentifier getKeyAlg()
+    {
+        return keyAlg;
+    }
+
+    public ASN1OctetString getValueHint()
+    {
+        return valueHint;
+    }
+
+    public DERBitString getEncValue()
+    {
+        return encValue;
+    }
+
+    /**
+     * <pre>
+     * EncryptedValue ::= SEQUENCE {
+     *                     intendedAlg   [0] AlgorithmIdentifier  OPTIONAL,
+     *                     -- the intended algorithm for which the value will be used
+     *                     symmAlg       [1] AlgorithmIdentifier  OPTIONAL,
+     *                     -- the symmetric algorithm used to encrypt the value
+     *                     encSymmKey    [2] BIT STRING           OPTIONAL,
+     *                     -- the (encrypted) symmetric key used to encrypt the value
+     *                     keyAlg        [3] AlgorithmIdentifier  OPTIONAL,
+     *                     -- algorithm used to encrypt the symmetric key
+     *                     valueHint     [4] OCTET STRING         OPTIONAL,
+     *                     -- a brief description or identifier of the encValue content
+     *                     -- (may be meaningful only to the sending entity, and used only
+     *                     -- if EncryptedValue might be re-examined by the sending entity
+     *                     -- in the future)
+     *                     encValue       BIT STRING }
+     *                     -- the encrypted value itself
+     * </pre>
+     * @return a basic ASN.1 object representation.
+     */
+    public ASN1Primitive toASN1Primitive()
+    {
+        ASN1EncodableVector v = new ASN1EncodableVector();
+
+        addOptional(v, 0, intendedAlg);
+        addOptional(v, 1, symmAlg);
+        addOptional(v, 2, encSymmKey);
+        addOptional(v, 3, keyAlg);
+        addOptional(v, 4, valueHint);
+
+        v.add(encValue);
+
+        return new DERSequence(v);
+    }
+
+    private void addOptional(ASN1EncodableVector v, int tagNo, ASN1Encodable obj)
+    {
+        if (obj != null)
+        {
+            v.add(new DERTaggedObject(false, tagNo, obj));
+        }
+    }
+}