001: package org.bouncycastle.sasn1.test;
002:
003: import java.io.ByteArrayOutputStream;
004: import java.io.InputStream;
005: import java.io.OutputStream;
006:
007: import junit.framework.Test;
008: import junit.framework.TestCase;
009: import junit.framework.TestSuite;
010:
011: import org.bouncycastle.asn1.cms.CMSObjectIdentifiers;
012: import org.bouncycastle.sasn1.Asn1InputStream;
013: import org.bouncycastle.sasn1.Asn1Integer;
014: import org.bouncycastle.sasn1.Asn1ObjectIdentifier;
015: import org.bouncycastle.sasn1.Asn1OctetString;
016: import org.bouncycastle.sasn1.Asn1Sequence;
017: import org.bouncycastle.sasn1.BerOctetString;
018: import org.bouncycastle.sasn1.BerOctetStringGenerator;
019: import org.bouncycastle.sasn1.BerSequence;
020: import org.bouncycastle.sasn1.BerSequenceGenerator;
021: import org.bouncycastle.sasn1.BerTag;
022: import org.bouncycastle.sasn1.DerSequenceGenerator;
023: import org.bouncycastle.sasn1.cms.CompressedDataParser;
024: import org.bouncycastle.sasn1.cms.ContentInfoParser;
025:
026: public class OctetStringTest extends TestCase {
027: public void testReadingWriting() throws Exception {
028: ByteArrayOutputStream bOut = new ByteArrayOutputStream();
029: BerOctetStringGenerator octGen = new BerOctetStringGenerator(
030: bOut);
031:
032: OutputStream out = octGen.getOctetOutputStream();
033:
034: out.write(new byte[] { 1, 2, 3, 4 });
035: out.write(new byte[4]);
036:
037: out.close();
038:
039: Asn1InputStream aIn = new Asn1InputStream(bOut.toByteArray());
040:
041: BerOctetString s = (BerOctetString) aIn.readObject();
042:
043: InputStream in = s.getOctetStream();
044: int count = 0;
045:
046: while (in.read() >= 0) {
047: count++;
048: }
049:
050: assertEquals(8, count);
051: }
052:
053: public void testReadingWritingZeroInLength() throws Exception {
054: ByteArrayOutputStream bOut = new ByteArrayOutputStream();
055: BerOctetStringGenerator octGen = new BerOctetStringGenerator(
056: bOut);
057:
058: OutputStream out = octGen.getOctetOutputStream();
059:
060: out.write(new byte[] { 1, 2, 3, 4 });
061: out.write(new byte[512]); // forces a zero to appear in length
062:
063: out.close();
064:
065: Asn1InputStream aIn = new Asn1InputStream(bOut.toByteArray());
066:
067: BerOctetString s = (BerOctetString) aIn.readObject();
068:
069: InputStream in = s.getOctetStream();
070: int count = 0;
071:
072: while (in.read() >= 0) {
073: count++;
074: }
075:
076: assertEquals(516, count);
077: }
078:
079: public void testReadingWritingNested() throws Exception {
080: ByteArrayOutputStream bOut = new ByteArrayOutputStream();
081: BerSequenceGenerator sGen = new BerSequenceGenerator(bOut);
082: BerOctetStringGenerator octGen = new BerOctetStringGenerator(
083: sGen.getRawOutputStream());
084:
085: OutputStream out = octGen.getOctetOutputStream();
086:
087: BerSequenceGenerator inSGen = new BerSequenceGenerator(out);
088:
089: BerOctetStringGenerator inOctGen = new BerOctetStringGenerator(
090: inSGen.getRawOutputStream());
091:
092: OutputStream inOut = inOctGen.getOctetOutputStream();
093:
094: inOut.write(new byte[] { 1, 2, 3, 4 });
095: inOut.write(new byte[10]);
096:
097: inOut.close();
098:
099: inSGen.close();
100:
101: out.close();
102:
103: sGen.close();
104:
105: Asn1InputStream aIn = new Asn1InputStream(bOut.toByteArray());
106:
107: BerSequence sq = (BerSequence) aIn.readObject();
108:
109: BerOctetString s = (BerOctetString) sq.readObject();
110:
111: Asn1InputStream aIn2 = new Asn1InputStream(s.getOctetStream());
112:
113: BerSequence sq2 = (BerSequence) aIn2.readObject();
114:
115: BerOctetString inS = (BerOctetString) sq2.readObject();
116:
117: InputStream in = inS.getOctetStream();
118: int count = 0;
119:
120: while (in.read() >= 0) {
121: count++;
122: }
123:
124: assertEquals(14, count);
125: }
126:
127: public void testNestedStructure() throws Exception {
128: ByteArrayOutputStream bOut = new ByteArrayOutputStream();
129:
130: BerSequenceGenerator sGen = new BerSequenceGenerator(bOut);
131:
132: sGen.addObject(new Asn1ObjectIdentifier(
133: CMSObjectIdentifiers.compressedData.getId()));
134:
135: BerSequenceGenerator cGen = new BerSequenceGenerator(sGen
136: .getRawOutputStream(), 0, true);
137:
138: cGen.addObject(new Asn1Integer(0));
139:
140: //
141: // AlgorithmIdentifier
142: //
143: DerSequenceGenerator algGen = new DerSequenceGenerator(cGen
144: .getRawOutputStream());
145:
146: algGen.addObject(new Asn1ObjectIdentifier("1.2"));
147:
148: algGen.close();
149:
150: //
151: // Encapsulated ContentInfo
152: //
153: BerSequenceGenerator eiGen = new BerSequenceGenerator(cGen
154: .getRawOutputStream());
155:
156: eiGen.addObject(new Asn1ObjectIdentifier("1.1"));
157:
158: BerOctetStringGenerator octGen = new BerOctetStringGenerator(
159: eiGen.getRawOutputStream(), 0, true);
160:
161: //
162: // output containing zeroes
163: //
164: OutputStream out = octGen.getOctetOutputStream();
165:
166: out.write(new byte[] { 1, 2, 3, 4 });
167: out.write(new byte[4]);
168: out.write(new byte[20]);
169:
170: out.close();
171: eiGen.close();
172: cGen.close();
173: sGen.close();
174:
175: //
176: // reading back
177: //
178: Asn1InputStream aIn = new Asn1InputStream(bOut.toByteArray());
179:
180: ContentInfoParser cp = new ContentInfoParser((Asn1Sequence) aIn
181: .readObject());
182:
183: CompressedDataParser comData = new CompressedDataParser(
184: (Asn1Sequence) cp.getContent(BerTag.SEQUENCE));
185: ContentInfoParser content = comData.getEncapContentInfo();
186:
187: Asn1OctetString bytes = (Asn1OctetString) content
188: .getContent(BerTag.OCTET_STRING);
189:
190: InputStream in = bytes.getOctetStream();
191: int count = 0;
192:
193: while (in.read() >= 0) {
194: count++;
195: }
196:
197: assertEquals(28, count);
198: }
199:
200: public static Test suite() {
201: return new TestSuite(OctetStringTest.class);
202: }
203: }
|