code: public static ASN1Set getInstance(
          ASN1TaggedObject    obj,
          boolean             explicit)
      {
          if (explicit)
          {
              if (!obj.isExplicit())
              {
                  throw new IllegalArgumentException("object implicit - explicit expected.");
              }
  
              return (ASN1Set)obj.getObject();
          }
          else
          {
              //
              // constructed object which appears to be explicitly tagged
              // and it's really implicit means we have to add the
              // surrounding sequence.
              //
              if (obj.isExplicit())
              {
                  ASN1Set    set = new DERSet(obj.getObject());
  
                  return set;
              }
              else
              {
                  if (obj.getObject() instanceof ASN1Set)
                  {
                      return (ASN1Set)obj.getObject();
                  }
  
                  //
                  // in this case the parser returns a sequence, convert it
                  // into a set.
                  //
                  ASN1EncodableVector  v = new ASN1EncodableVector();
  
                  if (obj.getObject() instanceof ASN1Sequence)
                  {
                      ASN1Sequence s = (ASN1Sequence)obj.getObject();
                      Enumeration e = s.getObjects();
  
                      while (e.hasMoreElements())
                      {
                          v.add((DEREncodable)e.nextElement());
                      }
  
                      return new DERSet(v, false);
                  }
              }
          }
  
          throw new IllegalArgumentException(
                      "unknown object in getInstanceFromTagged");
      }
docs: Return an ASN1 set from a tagged object. There is a special
  case here, if an object appears to have been explicitly tagged on
  reading but we were expecting it to be implictly tagged in the
  normal course of events it indicates that we lost the surrounding
  set - so we need to add it back (this will happen if the tagged
  object is a sequence that contains other sequences). If you are
  dealing with implicitly tagged sets you really <b>should</b>
  be using this method.
  
  @param obj the tagged object.
  @param explicit true if the object is meant to be explicitly tagged
  false otherwise.
  @exception IllegalArgumentException if the tagged object cannot
  be converted.