fixes issue with base64 decoding twice when generating tokens

* adds tests for default token generation #11
* adds Helpers class for static methods used in tests
* adds commons-codec dependency for base64 encoding
* Helpers uses a more concise HMAC-SHA1 signing routine than util.GenerateMac

Author: aoberoi

build.gradle

@@ -32,6 +32,7 @@ dependencies {
     compile group: 'org.codehaus.jackson', name: 'jackson-mapper-asl', version: '1.9.13'
     compile group: 'org.codehaus.jackson', name: 'jackson-core-asl', version: '1.9.13'
     compile group: 'commons-validator', name: 'commons-validator', version: '1.4.0'
+    compile group: 'commons-codec', name: 'commons-codec', version: '1.9'
     // TODO: find out how to initialize these dependencies properly, or remove them
     //compile group: 'org.slf4j', name: 'slf4j-api', version: '1.7.5'
     //compile group: 'org.slf4j', name: 'slf4j-simple', version: '1.7.5'

src/main/java/com/opentok/api/OpenTok.java

@@ -168,7 +168,7 @@ public String generateToken(String sessionId, String role, long expireTime, Stri
             throw new OpenTokSessionNotFoundException("Session not found");
         }
 
-        Session session = new Session(decodedSessionId, apiKey, apiSecret);
+        Session session = new Session(sessionId, apiKey, apiSecret);
         return session.generateToken(role, expireTime, connectionData);
     }
 

src/test/java/com/opentok/test/Helpers.java

@@ -0,0 +1,75 @@
+package com.opentok.test;
+
+import java.io.UnsupportedEncodingException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SignatureException;
+import java.util.Formatter;
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.commons.codec.binary.Base64;
+
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+import java.net.URLDecoder;
+
+/**
+ * Created by ankur on 4/14/14.
+ */
+public class Helpers {
+
+    private static final String HMAC_SHA1_ALGORITHM = "HmacSHA1";
+
+    public static Map<String, String> decodeToken(String token) throws UnsupportedEncodingException {
+        Map<String, String> tokenData = new HashMap<String, String>();
+        token = token.substring(4);
+        byte[] buffer = Base64.decodeBase64(token);
+        String decoded = new String(buffer, "UTF-8");
+        String[] decodedParts = decoded.split(":");
+        for (String part : decodedParts) {
+            tokenData.putAll(decodeFormData(part));
+        }
+        return tokenData;
+    }
+
+    public static boolean verifyTokenSignature(String token, String apiSecret) throws
+            UnsupportedEncodingException, NoSuchAlgorithmException, SignatureException, InvalidKeyException {
+        token = token.substring(4);
+        byte[] buffer = Base64.decodeBase64(token);
+        String decoded = new String(buffer, "UTF-8");
+        String[] decodedParts = decoded.split(":");
+        String signature = decodeToken(token).get("sig");
+        return (signature.equals(signData(decodedParts[1], apiSecret)));
+    }
+
+    private static Map<String, String> decodeFormData(String formData) throws UnsupportedEncodingException {
+        Map<String, String> decodedFormData = new HashMap<String, String>();
+        String[] pairs = formData.split("\\&");
+        for (int i = 0; i < pairs.length; i++) {
+            String[] fields = pairs[i].split("=");
+            String name = URLDecoder.decode(fields[0], "UTF-8");
+            String value = URLDecoder.decode(fields[1], "UTF-8");
+            decodedFormData.put(name, value);
+        }
+        return decodedFormData;
+    }
+
+    // -- credit: https://gist.github.com/ishikawa/88599
+
+    private static String toHexString(byte[] bytes) {
+        Formatter formatter = new Formatter();
+        for (byte b : bytes) {
+            formatter.format("%02x", b);
+        }
+        return formatter.toString();
+    }
+
+    private static String signData(String data, String key)
+            throws SignatureException, NoSuchAlgorithmException, InvalidKeyException
+    {
+        SecretKeySpec signingKey = new SecretKeySpec(key.getBytes(), HMAC_SHA1_ALGORITHM);
+        Mac mac = Mac.getInstance(HMAC_SHA1_ALGORITHM);
+        mac.init(signingKey);
+        return toHexString(mac.doFinal(data.getBytes()));
+    }
+}

src/test/java/com/opentok/test/OpenTokTest.java

@@ -6,11 +6,17 @@
 
 package com.opentok.test;
 
+import java.io.UnsupportedEncodingException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SignatureException;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Map.Entry;
 
+import com.opentok.test.Helpers;
+
 import com.opentok.api.OpenTok;
 import com.opentok.api.Session;
 import com.opentok.api.constants.Version;
@@ -153,28 +159,27 @@ public void testCreateBadSession() throws OpenTokException {
 
     // TODO: test session creation conditions that result in errors
 
-//    @Test
-//    public void testRoleDefault() throws OpenTokException {
-//        Session s= sdk.createSession();
-//        String t = s.generateToken();
-//        TokBoxXML xml = get_token_info(t);
-//
-//        String expectedRole = "publisher";
-//        String actualRole = xml.getElementValue("role", "token").trim();
-//        Assert.assertEquals("Java SDK tests: role default not default (publisher)", expectedRole, actualRole);
-//
-//        // Permissions are set as an empty node in the xml
-//        // Verify that the expected permission node is there
-//        // Verify nodes for permissions not granted to the role are not there
-//        Assert.assertTrue("Java SDK tests: default role does not have subscriber permissions", xml.hasElement("subscribe", "permissions"));
-//        Assert.assertTrue("Java SDK tests: default role does not have publisher permissions", xml.hasElement("publish", "permissions"));
-//        Assert.assertTrue("Java SDK tests: default role does not have signal permissions", xml.hasElement("signal", "permissions"));
-//        Assert.assertFalse("Java SDK tests: default role should not have forceunpublish permissions", xml.hasElement("forceunpublish", "permissions"));
-//        Assert.assertFalse("Java SDK tests: default role should not have forcedisconnect permissions", xml.hasElement("forcedisconnect", "permissions"));
-//        Assert.assertFalse("Java SDK tests: default role should not have record permissions", xml.hasElement("record", "permissions"));
-//        Assert.assertFalse("Java SDK tests: default role should not have playback permissions", xml.hasElement("playback", "permissions"));
-//    }
-//
+    @Test
+    public void testRoleDefault() throws
+            OpenTokException, UnsupportedEncodingException, NoSuchAlgorithmException, SignatureException,
+            InvalidKeyException {
+
+        int apiKey = 123456;
+        String apiSecret = "1234567890abcdef1234567890abcdef1234567890";
+        OpenTok opentok = new OpenTok(apiKey, apiSecret);
+        String sessionId = "1_MX4xMjM0NTZ-flNhdCBNYXIgMTUgMTQ6NDI6MjMgUERUIDIwMTR-MC40OTAxMzAyNX4";
+
+        String token = opentok.generateToken(sessionId);
+
+        assertNotNull(token);
+        assertTrue(Helpers.verifyTokenSignature(token, apiSecret));
+
+        Map<String, String> tokenData = Helpers.decodeToken(token);
+        assertEquals(Integer.toString(apiKey), tokenData.get("partner_id"));
+        assertNotNull(tokenData.get("create_time"));
+        assertNotNull(tokenData.get("nonce"));
+    }
+
 //    @Test
 //    public void testRolePublisher() throws OpenTokException {
 //        Session s= sdk.createSession();