From 3479850ccc76dfac2986dd521d87f08cdee697c2 Mon Sep 17 00:00:00 2001 From: Vincent Breitmoser Date: Sun, 13 Jul 2014 16:26:26 +0200 Subject: [PATCH] test: work on KeyringTestingHelper methods --- .../support/KeyringTestingHelper.java | 128 ++++++++++++++++-- 1 file changed, 117 insertions(+), 11 deletions(-) diff --git a/OpenKeychain-Test/src/test/java/org/sufficientlysecure/keychain/support/KeyringTestingHelper.java b/OpenKeychain-Test/src/test/java/org/sufficientlysecure/keychain/support/KeyringTestingHelper.java index 7bbb4e98e..398b2393e 100644 --- a/OpenKeychain-Test/src/test/java/org/sufficientlysecure/keychain/support/KeyringTestingHelper.java +++ b/OpenKeychain-Test/src/test/java/org/sufficientlysecure/keychain/support/KeyringTestingHelper.java @@ -25,17 +25,17 @@ import org.sufficientlysecure.keychain.provider.ProviderHelper; import org.sufficientlysecure.keychain.service.OperationResults; import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.util.Collection; import java.util.Collections; import java.util.Comparator; import java.util.HashSet; +import java.util.Iterator; import java.util.List; -/** - * Helper for tests of the Keyring import in ProviderHelper. - */ +/** Helper methods for keyring tests. */ public class KeyringTestingHelper { private final Context context; @@ -68,40 +68,100 @@ public class KeyringTestingHelper { return saveSuccess; } + public static byte[] removePacket(byte[] ring, int position) throws IOException { + Iterator it = parseKeyring(ring); + ByteArrayOutputStream out = new ByteArrayOutputStream(ring.length); + + int i = 0; + while(it.hasNext()) { + // at the right position, skip the packet + if(i++ == position) { + continue; + } + // write the old one + out.write(it.next().buf); + } + + if (i <= position) { + throw new IndexOutOfBoundsException("injection index did not not occur in stream!"); + } + + return out.toByteArray(); + } + + public static byte[] injectPacket(byte[] ring, byte[] inject, int position) throws IOException { + + Iterator it = parseKeyring(ring); + ByteArrayOutputStream out = new ByteArrayOutputStream(ring.length + inject.length); + + int i = 0; + while(it.hasNext()) { + // at the right position, inject the new packet + if(i++ == position) { + out.write(inject); + } + // write the old one + out.write(it.next().buf); + } + + if (i <= position) { + throw new IndexOutOfBoundsException("injection index did not not occur in stream!"); + } + + return out.toByteArray(); + + } + + /** This class contains a single pgp packet, together with information about its position + * in the keyring and its packet tag. + */ public static class RawPacket { public int position; + + // packet tag for convenience, this can also be read from the header public int tag; - public int length; + + public int headerLength, length; + // this buf includes the header, so its length is headerLength + length! public byte[] buf; + @Override public boolean equals(Object other) { return other instanceof RawPacket && Arrays.areEqual(this.buf, ((RawPacket) other).buf); } + @Override public int hashCode() { - // System.out.println("tag: " + tag + ", code: " + Arrays.hashCode(buf)); return Arrays.hashCode(buf); } } + /** A comparator which compares RawPackets by their position */ public static final Comparator packetOrder = new Comparator() { public int compare(RawPacket left, RawPacket right) { return Integer.compare(left.position, right.position); } }; + /** Diff two keyrings, returning packets only present in one keyring in its associated List. + * + * Packets in the returned lists are annotated and ordered by their original order of appearance + * in their origin keyrings. + * + * @return true if keyrings differ in at least one packet + */ public static boolean diffKeyrings(byte[] ringA, byte[] ringB, List onlyA, List onlyB) throws IOException { - InputStream streamA = new ByteArrayInputStream(ringA); - InputStream streamB = new ByteArrayInputStream(ringB); + Iterator streamA = parseKeyring(ringA); + Iterator streamB = parseKeyring(ringB); HashSet a = new HashSet(), b = new HashSet(); RawPacket p; int pos = 0; while(true) { - p = readPacket(streamA); + p = streamA.next(); if (p == null) { break; } @@ -110,7 +170,7 @@ public class KeyringTestingHelper { } pos = 0; while(true) { - p = readPacket(streamB); + p = streamB.next(); if (p == null) { break; } @@ -132,6 +192,51 @@ public class KeyringTestingHelper { return !onlyA.isEmpty() || !onlyB.isEmpty(); } + /** Creates an iterator of RawPackets over a binary keyring. */ + public static Iterator parseKeyring(byte[] ring) { + + final InputStream stream = new ByteArrayInputStream(ring); + + return new Iterator() { + RawPacket next; + + @Override + public boolean hasNext() { + if (next == null) try { + next = readPacket(stream); + } catch (IOException e) { + return false; + } + return next != null; + } + + @Override + public RawPacket next() { + if (!hasNext()) { + return null; + } + try { + return next; + } finally { + next = null; + } + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + }; + + } + + /** Read a single (raw) pgp packet from an input stream. + * + * Note that the RawPacket.position field is NOT set here! + * + * Variable length packets are not handled here. we don't use those in our test classes, and + * otherwise rely on BouncyCastle's own unit tests to handle those correctly. + */ private static RawPacket readPacket(InputStream in) throws IOException { // save here. this is tag + length, max 6 bytes @@ -149,8 +254,8 @@ public class KeyringTestingHelper { } boolean newPacket = (hdr & 0x40) != 0; - int tag = 0; - int bodyLen = 0; + int tag; + int bodyLen; if (newPacket) { tag = hdr & 0x3f; @@ -207,6 +312,7 @@ public class KeyringTestingHelper { } RawPacket p = new RawPacket(); p.tag = tag; + p.headerLength = headerLength; p.length = bodyLen; p.buf = buf; return p;