Using binary payload with IdentityMapV3

Author: aulme

src/main/java/com/uid2/client/EnvelopeV2.java

@@ -2,19 +2,23 @@
 
 
 public class EnvelopeV2 {
-  EnvelopeV2(String envelope, byte[] nonce) {
-    this.envelope = envelope;
+  EnvelopeV2(byte[] envelope, byte[] nonce) {
+    this.binaryEnvelope = envelope;
     this.nonce = nonce;
   }
 
   /**
    * @return an encrypted request envelope which can be used in the POST body of a <a href="https://unifiedid.com/docs/endpoints/summary-endpoints">UID2 endpoint</a>.
    * See <a href="https://unifiedid.com/docs/getting-started/gs-encryption-decryption#encrypted-request-envelope">Encrypted Request Envelope</a>
    */
-  public String getEnvelope() { return envelope; }
+  public String getEnvelope() { return InputUtil.byteArrayToBase64(binaryEnvelope); }
   byte[] getNonce() { return nonce;}
 
-  private final String envelope;
+  public byte[] getBinaryEnvelope() {
+    return binaryEnvelope;
+  }
+
+  private final byte[] binaryEnvelope;
   private final byte[] nonce;
 }
 

src/main/java/com/uid2/client/IdentityMapClient.java

@@ -19,7 +19,7 @@ public IdentityMapClient(String uid2BaseUrl, String clientApiKey, String base64S
     public IdentityMapResponse generateIdentityMap(IdentityMapInput identityMapInput) {
         EnvelopeV2 envelope = identityMapHelper.createEnvelopeForIdentityMapRequest(identityMapInput);
 
-        String responseString = uid2ClientHelper.makeRequest(envelope, "/v2/identity/map");
+        String responseString = uid2ClientHelper.makeRequest("/v2/identity/map", envelope).getAsString();
         return identityMapHelper.createIdentityMapResponse(responseString, envelope, identityMapInput);
     }
 

src/main/java/com/uid2/client/IdentityMapV3Client.java

@@ -19,8 +19,12 @@ public IdentityMapV3Client(String uid2BaseUrl, String clientApiKey, String base6
     public IdentityMapV3Response generateIdentityMap(IdentityMapV3Input identityMapInput) {
         EnvelopeV2 envelope = identityMapHelper.createEnvelopeForIdentityMapRequest(identityMapInput);
 
-        String responseString = uid2ClientHelper.makeRequest(envelope, "/v3/identity/map");
-        return identityMapHelper.createIdentityMapResponse(responseString, envelope, identityMapInput);
+        Uid2Response response = uid2ClientHelper.makeBinaryRequest("/v3/identity/map", envelope);
+        if (response.isBinary()) {
+            return identityMapHelper.createIdentityMapResponse(response.getAsBytes(), envelope, identityMapInput);
+        } else {
+            return identityMapHelper.createIdentityMapResponse(response.getAsString(), envelope, identityMapInput);
+        }
     }
 
     private final IdentityMapV3Helper identityMapHelper;

src/main/java/com/uid2/client/IdentityMapV3Helper.java

@@ -31,5 +31,10 @@ public IdentityMapV3Response createIdentityMapResponse(String responseString, En
         return new IdentityMapV3Response(decryptedResponseString, identityMapInput);
     }
 
+    public IdentityMapV3Response createIdentityMapResponse(byte[] response, EnvelopeV2 envelope, IdentityMapV3Input identityMapInput) {
+        String decryptedResponseString = uid2Helper.decrypt(response, envelope.getNonce());
+        return new IdentityMapV3Response(decryptedResponseString, identityMapInput);
+    }
+
     private final Uid2Helper uid2Helper;
 }

src/main/java/com/uid2/client/PublisherUid2Client.java

@@ -21,7 +21,7 @@ public PublisherUid2Client(String uid2BaseUrl, String clientApiKey, String base6
     public IdentityTokens generateToken(TokenGenerateInput tokenGenerateInput) {
         EnvelopeV2 envelope = publisherUid2Helper.createEnvelopeForTokenGenerateRequest(tokenGenerateInput);
 
-        String responseString = uid2ClientHelper.makeRequest(envelope, "/v2/token/generate");
+        String responseString = uid2ClientHelper.makeRequest("/v2/token/generate", envelope).getAsString();
         return publisherUid2Helper.createIdentityfromTokenGenerateResponse(responseString, envelope);
     }
 
@@ -33,7 +33,7 @@ public IdentityTokens generateToken(TokenGenerateInput tokenGenerateInput) {
     public TokenGenerateResponse generateTokenResponse(TokenGenerateInput tokenGenerateInput) {
         EnvelopeV2 envelope = publisherUid2Helper.createEnvelopeForTokenGenerateRequest(tokenGenerateInput);
 
-        String responseString = uid2ClientHelper.makeRequest(envelope, "/v2/token/generate");
+        String responseString = uid2ClientHelper.makeRequest("/v2/token/generate", envelope).getAsString();
         return publisherUid2Helper.createTokenGenerateResponse(responseString, envelope);
     }
 
@@ -42,7 +42,7 @@ public TokenGenerateResponse generateTokenResponse(TokenGenerateInput tokenGener
      * @return the refreshed IdentityTokens instance (with a new advertising token and updated expiry times). Typically, this will be used to replace the current identity in the user's session
      */
     public TokenRefreshResponse refreshToken(IdentityTokens currentIdentity) {
-        String responseString = uid2ClientHelper.makeRequest(currentIdentity.getRefreshToken(), "/v2/token/refresh");
+        String responseString = uid2ClientHelper.makeRequest("/v2/token/refresh", currentIdentity.getRefreshToken()).getAsString();
         return PublisherUid2Helper.createTokenRefreshResponse(responseString, currentIdentity);
     }
 

src/main/java/com/uid2/client/TokenHelper.java

@@ -48,7 +48,7 @@ EncryptionDataResponse encryptRawUidIntoToken(String rawUid, Instant now) {
     RefreshResponse refresh(String urlSuffix) {
         try{
             EnvelopeV2 envelope = uid2Helper.createEnvelopeV2("".getBytes());
-            String responseString = uid2ClientHelper.makeRequest(envelope, urlSuffix);
+            String responseString = uid2ClientHelper.makeRequest(urlSuffix, envelope).getAsString();
             byte[] response = uid2Helper.decrypt(responseString, envelope.getNonce()).getBytes();
             this.container.set(KeyParser.parse(new ByteArrayInputStream(response)));
             return RefreshResponse.makeSuccess();

src/main/java/com/uid2/client/Uid2ClientHelper.java

@@ -3,6 +3,7 @@
 import okhttp3.*;
 
 import java.io.IOException;
+import java.util.Objects;
 
 public class Uid2ClientHelper {
     Uid2ClientHelper(String baseUrl, String clientApiKey) {
@@ -17,51 +18,73 @@ static Headers getHeaders(String clientApiKey) {
                 .build();
     }
 
-    String makeRequest(EnvelopeV2 envelope, String urlSuffix) {
-        return makeRequest(envelope.getEnvelope(), urlSuffix);
+    Uid2Response makeRequest(String urlSuffix, EnvelopeV2 envelope) {
+        return makeRequest(urlSuffix, getEnvelope(envelope));
     }
 
-    String makeRequest(String requestBody, String urlSuffix) {
+    Uid2Response makeRequest(String urlSuffix, String payload) {
+        return makeRequest(RequestBody.create(payload, FORM), urlSuffix);
+    }
+
+    private static String getEnvelope(EnvelopeV2 envelope) {
+        return envelope.getEnvelope();
+    }
+
+    Uid2Response makeBinaryRequest(String urlSuffix, EnvelopeV2 envelope) {
+        return makeRequest(RequestBody.create(envelope.getBinaryEnvelope(), BINARY), urlSuffix);
+    }
+
+    Uid2Response makeRequest(RequestBody body, String urlSuffix) {
         Request request = new Request.Builder()
                 .url(baseUrl + urlSuffix)
                 .headers(headers)
-                .post(RequestBody.create(requestBody, FORM))
+                .post(body)
                 .build();
 
-
         try (Response response = client.newCall(request).execute()) {
             if (!response.isSuccessful()) {
                 throw new Uid2Exception("Unexpected code " + response);
             }
-
             return getResponse(response);
         } catch (IOException e) {
             throw new Uid2Exception("error communicating with api endpoint", e);
         }
     }
 
-    private static String getResponse(Response response) {
-        String responseString;
+    private static Uid2Response getResponse(Response response) {
+        Uid2Response uid2Response;
 
         try {
             if (response == null) {
                 throw new Uid2Exception("Response is null");
             }
             else {
-                responseString = response.body() != null ? response.body().string() : response.toString();
+                if (responseIsBinary(response)) {
+                    byte[] bytes = response.body() != null ? response.body().bytes() : new byte[0];
+                    uid2Response = Uid2Response.fromBytes(bytes);
+                } else {
+                    String string = response.body() != null ? response.body().string() : response.toString();
+                    uid2Response = Uid2Response.fromString(string);
+                }
+
                 if (!response.isSuccessful()) {
-                    throw new Uid2Exception("Unexpected code " + responseString);
+                    throw new Uid2Exception("Unexpected code " + response);
                 }
             }
-            return responseString;
+            return uid2Response;
         } catch (IOException e) {
             throw new Uid2Exception("Error communicating with api endpoint", e);
         }
     }
 
+    private static boolean responseIsBinary(Response response) {
+        return Objects.equals(response.headers().get("Content-Type"), "application/octet-stream");
+    }
+
     private final OkHttpClient client = new OkHttpClient();
     private final String baseUrl;
     private final Headers headers;
     private final static MediaType FORM = MediaType.get("application/x-www-form-urlencoded");
+    private final static MediaType BINARY = MediaType.get("application/octet-stream");
 
 }

src/main/java/com/uid2/client/Uid2Helper.java

@@ -1,5 +1,7 @@
 package com.uid2.client;
 
+import org.jetbrains.annotations.NotNull;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.ByteBuffer;
@@ -30,20 +32,28 @@ public EnvelopeV2 createEnvelopeV2(byte[] nonce, Instant timestamp, byte[] iv, b
         final byte envelopeVersion = 1;
         envelopeBuffer.put(envelopeVersion);
         envelopeBuffer.put(encrypted);
-        return new EnvelopeV2(InputUtil.byteArrayToBase64(envelopeBuffer.array()), nonce);
+        return new EnvelopeV2(envelopeBuffer.array(), nonce);
     }
 
     public String decrypt(String response, byte[] nonceInRequest) {
         return decrypt(response, secretKey, false, nonceInRequest);
     }
 
+    public String decrypt(byte[] response, byte[] nonceInRequest) {
+        return decrypt(response, secretKey, false, nonceInRequest);
+    }
+
     static String decryptTokenRefreshResponse(String response, byte[] secretKey) {
         return decrypt(response, secretKey, true, null);
     }
 
     private static String decrypt(String response, byte[] secretKey, boolean isRefreshResponse, byte[] nonceInRequest) {
         //from parseV2Response
         byte[] responseBytes = InputUtil.base64ToByteArray(response);
+        return decrypt(responseBytes, secretKey, isRefreshResponse, nonceInRequest);
+    }
+
+    private static String decrypt(byte[] responseBytes, byte[] secretKey, boolean isRefreshResponse, byte[] nonceInRequest) {
         byte[] payload = Uid2Encryption.decryptGCM(responseBytes, 0, secretKey);
 
         byte[] resultBytes;

src/main/java/com/uid2/client/Uid2Response.java

@@ -0,0 +1,31 @@
+package com.uid2.client;
+
+public class Uid2Response {
+    String asString;
+    byte[] asBytes;
+
+    private Uid2Response(String asString, byte[] asBytes) {
+        this.asString = asString;
+        this.asBytes = asBytes;
+    }
+
+    public static Uid2Response fromString(String asString) {
+        return new Uid2Response(asString, null);
+    }
+
+    public static Uid2Response fromBytes(byte[] asBytes) {
+        return new Uid2Response(null, asBytes);
+    }
+
+    public String getAsString() {
+        return asString;
+    }
+
+    public byte[] getAsBytes() {
+        return asBytes;
+    }
+
+    public boolean isBinary() {
+        return asBytes != null;
+    }
+}