Measurement API

$consumer_key = 'STRING32CHARACTERS11223344556677';
$private_key = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';
 
$params = array(
'cost' => 0.01,
'cost_model' => 'cpc'
);
$mcrypt_iv = substr($consumer_key, 0, 16);
$query_str = http_build_query($params);
 
$enc_raw = mcrypt_encrypt( MCRYPT_RIJNDAEL_128, $private_key, $query_str, 'cbc', $mcrypt_iv);
$enc_str = bin2hex( $enc_raw );
 
echo $enc_str ;

import string
import urlparse
import urllib
import time
import requests
 
 
def generate_signature(api_key, http_method, host, uri, timestamp, post_params=""):
    string_to_sign = http_method + "\n" + host + "\n" + uri + "\n" + timestamp + "\n" + post_params
    dig = hmac.new(api_key, msg=string_to_sign, digestmod=hashlib.sha256).digest()
    signature = base64.urlsafe_b64encode(dig)
    return string.rstrip(signature, '=')
 
advertiser_id = YOUR_ADVERTISER_ID
api_key = YOUR_PRIVATE_KEY
consumer_key = YOUR_CONSUMER_KEY
method = 'GET'
host = advertiser_id + '.measure.mobileapptracking.com'
path = '/serve'
timestamp = str(int(time.time()))
 
params = {
    'action': 'install',
    'advertiser_id': advertiser_id,
    'sdk': 'server',
    'site_id': '2960',
    'ios_ifa': 'AAAAAA-BBBB-CCCC-11111-2222222222222',
    'ios_ad_tracking_disabled': '0',
    'ios_ifv': 'ZZZZZZ-BBBB-CCCC-11111-2222222222222',
    'user_id': '10000000001',
    'device_ip': '123.123.123.123',
    'device_brand': 'Apple',
    'device_model': 'iPhone5,2',
    'device_carrier': 'Verizon',
    'country_code': 'US',
    'response_format': 'json',
}
 
url = urlparse.urlparse('https://' + host + path + '?' + urllib.urlencode(params))
 
signature = generate_signature(api_key, 'GET', url.netloc, url.path + '?' + url.query, timestamp)
 
headers = {
    'mat-consumer-key': consumer_key,
    'mat-signature': signature,
    'mat-timestamp': timestamp,
}
requests.get(url.geturl(), headers=headers)

<?php
$advertiser_id = YOUR_ADVERTISER_ID;
$api_key = YOUR_PRIVATE_KEY;
$consumer_key = YOUR_CONSUMER_KEY;
$method = 'GET';
$host = $advertiser_id . '.measure.mobileapptracking.com';
$timestamp = UNIX_TIMESTAMP;
 
$param_str = 'action=session' 
    . '&advertiser_id=' . $advertiser_id 
    . '&sdk=server&site_id=2960' 
    . '&ios_ifa=AAAAAA-BBBB-CCCC-11111-2222222222222' 
    . '&ios_ad_tracking_disabled=0' 
    . '&ios_ifv=ZZZZZZ-BBBB-CCCC-11111-2222222222222' 
    . '&user_id=10000000001' 
    . '&device_ip=123.123.123.123' 
    . '&device_brand=Apple' 
    . '&device_model=iPhone5,2' 
    . '&device_carrier=Verizon' 
    . '&country_code=US' 
    . '&response_format=json' ;
 
$uri = '/serve?' . $param_str;
 
$signature = generateSignature( $api_key, $method, $host, $uri, $timestamp );
 
$options = array(
    CURLOPT_HTTPHEADER => array(
        'mat-consumer-key: ' . $consumer_key,
        'mat-signature: ' . $signature,
        'mat-timestamp: ' . $timestamp,
    )
);
 
$ch = curl_init( 'https://' + host + uri );
curl_setopt_array($ch, $options);
curl_exec($ch);
curl_close($ch); 
 
function generateSignature($api_key, $method, $host, $uri, $timestamp) {
   $string_to_sign 
       = $method . "\n" . $host . "\n" . $uri . "\n" . $timestamp . "\n";      
   $hash = hash_hmac("sha256", $string_to_sign, $api_key, true);
   // base64 encode string and then replacing / with _ and + with -
   $signature = base64_encode_url_safe($hash);
  // strip trailing equal signs
   $signature = rtrim($signature, '=');
   return $signature;
}
function base64_encode_url_safe($input) {
   return strtr(base64_encode($input), '+/', '-_');
}

'session',
    advertiser_id => $advertiser_id,
    sdk => 'server',
    response_format => 'json',
    site_id => '2960',
    ios_ifa => 'AAAAAA-BBBB-CCCC-11111-2222222222222',
    ios_ad_tracking_disabled => '0',
    ios_ifv => 'ZZZZZZ-BBBB-CCCC-11111-2222222222222',
    user_id => '10000000001',
    device_ip => '123.123.123.123',    
    device_brand => 'Apple',
    device_model => 'iPhone5,2',
    device_carrier => 'Verizon',
    country_code => 'US'
);
 
$param_str = urlencodeParams( $params );
 
$uri =  '/serve';
 
$signature = generateSignature($api_key, $method, $host, $uri, $timestamp, $param_str);
 
$options = array(
    CURLOPT_POSTFIELDS => $param_str,
    CURLOPT_HTTPHEADER => array(
        'mat-consumer-key: ' . $consumer_key,
        'mat-signature: ' . $signature,
        'mat-timestamp: ' . $timestamp,
    )
);
 
$ch = curl_init( 'https://' + host + uri );
curl_setopt_array($ch, $options);
curl_exec($ch);
curl_close($ch); 
 
function urlencodeParams( $params ) {
       ksort( $params );  // Sort parameter key-value pairs by key; else MAT cannot match the signature.
       $string = '';
       foreach ($params as $key => $value) {
              $string .= '&' . $key . '=' . urlencode($value);
       }    
       return $string;
}
 
function generateSignature($api_key, $method, $host, $uri, $timestamp, $param_str) {    
   $string_to_sign 
        = $method . "\n" . $host . "\n" . $uri . "\n" . $timestamp . "\n" . $param_str;      
   $hash = hash_hmac("sha256", $string_to_sign, $api_key, true);
   // base64 encode string and then replacing / with _ and + with -
   $signature = base64_encode_url_safe($hash);
   // strip trailing equal signs
   $signature = rtrim($signature, '=');
   return $signature;
}
function base64_encode_url_safe($input) {
   return strtr(base64_encode($input), '+/', '-_');

package reqcrypt

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "errors"
    "net/http"
    "net/url"
    "sort"
    "strconv"
    "strings"
    "time"
)

var (
    ErrBadHttpRequest    = errors.New("unable to create http request")
    ErrBadPostData       = errors.New("POST parameters may only have single value")
    ErrInvalidHttpMethod = errors.New("http method must be GET or POST")
    ErrPostParamsOnGet   = errors.New("received POST params on GET request")
)

// NewSignedGet creates a signed http GET request.
func NewSignedGet(consumerKey, privateKey, url string) (*http.Request, error) {

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return nil, ErrBadHttpRequest
    }

    // sign with private key
    curtime := int32(time.Now().Unix())
    curTimeStr := strconv.FormatInt(int64(curtime), 10)
    signature, _ := GenerateSignature(privateKey, "GET", req.URL.Host, req.URL.RequestURI(), curTimeStr, "")

    addMatHeaders(req, consumerKey, signature, curTimeStr)
    return req, nil
}

// NewSignedPost creates a signed http POST request.
func NewSignedPost(consumerKey, privateKey, url string, postVals url.Values) (*http.Request, error) {

    // same dance as http.PostForm
    req, err := http.NewRequest("POST", url, strings.NewReader(postVals.Encode()))
    if err != nil {
        return nil, ErrBadHttpRequest
    }
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

    // sorted, url-encoded post param string
    encodedVals, err := EncodePostParams(postVals)
    if err != nil {
        return nil, ErrBadPostData
    }

    // sign with private key
    curtime := int32(time.Now().Unix())
    curTimeStr := strconv.FormatInt(int64(curtime), 10)
    signature, _ := GenerateSignature(privateKey, "POST", req.URL.Host, req.URL.RequestURI(), curTimeStr, encodedVals)

    addMatHeaders(req, consumerKey, signature, curTimeStr)
    return req, nil
}

func addMatHeaders(req *http.Request, consumerKey, signature, curTimeStr string) {
    req.Header.Add("mat-consumer-key", consumerKey)
    req.Header.Add("mat-signature", signature)
    req.Header.Add("mat-timestamp", curTimeStr)
}

// EncodePostParams serializes POST parameters to a string for signing.
func EncodePostParams(postVals url.Values) (string, error) {

    // sorted keys
    keys := make([]string, 0, len(postVals))
    for k := range postVals {
        keys = append(keys, k)
    }
    sort.Strings(keys)

    // emit url-encoded string in sorted key order
    var buf bytes.Buffer
    for _, k := range keys {

        // exactly one value for each POST arg
        curData := postVals[k]
        if len(curData) != 1 {
            return "", ErrBadPostData
        }

        buf.WriteByte('&')
        buf.WriteString(k)
        buf.WriteByte('=')
        buf.WriteString(url.QueryEscape(curData[0]))
    }

    return buf.String(), nil
}

// GenerateSignature computes a signature hash according to the MAT server-to-server auth spec.
func GenerateSignature(privateKey, httpMethod, httpHost, uri, timestampStr, postParams string) (string, error) {

    // sanity checks
    if httpMethod != "GET" && httpMethod != "POST" {
        return "", ErrInvalidHttpMethod
    }

    // conservative buffer size to avoid reallocs
    const numNewLines = 5
    bufSize := len(httpMethod) + len(httpHost) + len(uri) + len(timestampStr) + len(postParams) + numNewLines

    // string-to-sign
    buf := bytes.NewBuffer(make([]byte, 0, bufSize))
    buf.WriteString(httpMethod)
    buf.WriteByte('\n')
    buf.WriteString(httpHost)
    buf.WriteByte('\n')
    buf.WriteString(uri)
    buf.WriteByte('\n')
    buf.WriteString(timestampStr)
    buf.WriteByte('\n')
    buf.WriteString(postParams)

    // sign with private key
    mac := hmac.New(sha256.New, []byte(privateKey))
    mac.Write(buf.Bytes())

    // strip padding from base64 encoding
    paddedSig := base64.URLEncoding.EncodeToString(mac.Sum(nil))
    return strings.TrimRight(paddedSig, "="), nil
}

package reqcrypt

import (
    "net/url"
    "strconv"
    "testing"
    "time"
)

var signatureTests = []struct {
    privateKey     string
    consumerKey    string
    timestampStr   string
    httpMethod     string
    httpHost       string
    uri            string
    postVals       url.Values
    truthSignature string
}{
    // GET
    {"adv1", "18d84eb30b59b5f3cc748bfe9f68b472", "1406146778",
        "GET", "engine.mobileapptracking.com", "/serve", make(url.Values),
        "ur3aUlwbRXGcxxt0EvDa2BQTqkCUjb4RdHww1S5EAWY"},

    // POST with params
    {"adv1", "18d84eb30b59b5f3cc748bfe9f68b472", "1406146778",
        "POST", "engine.mobileapptracking.com", "/serve", url.Values{"var1": []string{"blue"}},
        "X5wxZPS_s5941_d_wnaUcS1Qgd1jZvu94jv5aImtaxo"},

    // POST with params requiring url encoding and key sort
    {"adv1", "18d84eb30b59b5f3cc748bfe9f68b472", "1406146778",
        "POST", "engine.mobileapptracking.com", "/serve",
        url.Values{"var1": []string{"blue"}, "meow": []string{"+-="}, "alpha": []string{"beta"}},
        "_2fqNArAgJO3vvtE0ff3XZ3mYSsnIbu5Ynkaw-S-o-c"},
}

func TestGenerateSignature(t *testing.T) {
    for tidx, tcase := range signatureTests {

        // encode POST query params if needed
        postParams := ""
        if tcase.httpMethod == "POST" {
            var err error
            postParams, err = EncodePostParams(tcase.postVals)
            if err != nil {
                t.Errorf("case: %d, non-empty error: %s", tidx, err)
            }
        }

        // generate signature
        testSignature, testError := GenerateSignature(tcase.privateKey, tcase.httpMethod,
            tcase.httpHost, tcase.uri, tcase.timestampStr, postParams)

        // validate signature against truth data
        if testSignature != tcase.truthSignature {
            t.Errorf("case: %d, received=%s, wanted=%s", tidx, testSignature, tcase.truthSignature)
        }
        if testError != nil {
            t.Errorf("case: %d, non-empty error: %s", tidx, testError)
        }
    }
}

func BenchmarkNewSignedGet(b *testing.B) {
    consumerKey := "publickey"
    privateKey := "privatekey"
    u := "http://123213.measurement.mobileapptracking.com/collect/" +
        "click?pub_id=123&woof_id=22&campaign_id=5&payout=1000"

    for n := 0; n < b.N; n++ {
        NewSignedGet(consumerKey, privateKey, u)
    }
}

func BenchmarkNewSignedPost(b *testing.B) {
    consumerKey := "publickey"
    privateKey := "privatekey"
    u := "http://123213.measurement.mobileapptracking.com/collect/"

    params := make(url.Values)
    params.Add("pub_id", "123")
    params.Add("woof_id", "22")
    params.Add("campaign_id", "5")
    params.Add("payout", "1000")

    for n := 0; n < b.N; n++ {
        NewSignedPost(consumerKey, privateKey, u, params)
    }
}

func BenchmarkGenerateSignature(b *testing.B) {
    u := "http://123213.measurement.mobileapptracking.com/collect/" +
        "click?pub_id=123&woof_id=22&campaign_id=5&payout=1000"
    h := "123213.measurement.mobileapptracking.com"

    curtime := int32(time.Now().Unix())
    curTimeStr := strconv.FormatInt(int64(curtime), 10)

    for n := 0; n < b.N; n++ {
        GenerateSignature("privatekey", "GET", h, u, curTimeStr, "")
    }
}

import com.mashape.unirest.http.JsonNode;
import com.mashape.unirest.http.Unirest;
import com.mashape.unirest.http.exceptions.UnirestException;
import com.mashape.unirest.http.utils.URLParamEncoder;
import org.apache.commons.codec.binary.Base64;
 
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Date;
import java.util.LinkedHashMap;
 
 
public class Authentication {
    private static final String HMAC_SHA256_ALGORITHM = "HmacSHA256";
    private static final String ADVERTISER_ID = "YOUR_ADVERTISER_ID";
    private static final String SITE_ID = "YOUR_SITE_ID";
    private static final String API_KEY = "YOUR_PRIVATE_KEY";
    private static final String CONSUMER_KEY = "YOUR_CONSUMER_KEY";
    private static final String HOST = ADVERTISER_ID + ".measure.mobileapptracking.com";
    private static final String PATH = "/serve";
 
    public static void main(String[] args) throws UnirestException, NoSuchAlgorithmException, InvalidKeyException,
            UnsupportedEncodingException {
        System.out.println(getResponseBody(encodeUrlParams(ADVERTISER_ID, SITE_ID)));
        System.out.println(postResponseBody(encodeUrlParams(ADVERTISER_ID, SITE_ID)));
    }
 
    public static JsonNode getResponseBody(String encodedUrlParams) throws UnirestException,
            InvalidKeyException, NoSuchAlgorithmException, UnsupportedEncodingException {
        String httpMethod = "GET";
        String timestamp = String.valueOf(new Date().getTime());
        String url = "https://" + HOST + PATH + "?" + encodedUrlParams;
 
        String stringToSign = createStringToSign(httpMethod, HOST, PATH, encodedUrlParams, timestamp, "");
 
        return Unirest.get(url)
                .header("mat-consumer-key", CONSUMER_KEY)
                .header("mat-signature", generateSignature(stringToSign, API_KEY))
                .header("mat-timestamp", timestamp)
                .asJson()
                .getBody();
    }
 
    public static JsonNode postResponseBody(String encodedUrlParams) throws UnirestException, InvalidKeyException,
            NoSuchAlgorithmException, UnsupportedEncodingException {
        String httpMethod = "POST";
        String timestamp = String.valueOf(new Date().getTime());
        String url = "https://" + HOST + PATH;
 
        String stringToSign = createStringToSign(httpMethod, HOST, PATH, encodedUrlParams, timestamp, encodedUrlParams);
 
        return Unirest.post(url)
                .header("Content-Type", "application/x-www-form-urlencoded")
                .header("mat-consumer-key", CONSUMER_KEY)
                .header("mat-signature", generateSignature(stringToSign, API_KEY))
                .header("mat-timestamp", timestamp)
                .body(encodedUrlParams)
                .asJson()
                .getBody();
    }
 
    private static String encodeUrlParams(String advertiserId, String siteId) {
        LinkedHashMap<String, String> params = new LinkedHashMap<>();
        params.put("action", "install");
        params.put("advertiser_id", advertiserId);
        params.put("country_code", "US");
        params.put("device_brand", "Apple");
        params.put("device_carrier", "Verizon");
        params.put("device_ip", "123.123.123.123");
        params.put("device_model", "iPhone5,2");
        params.put("ios_ad_tracking_disabled", "0");
        params.put("ios_ifa", "AAAAAA-BBBB-CCCC-11111-2222222222222");
        params.put("ios_ifv", "ZZZZZZ-BBBB-CCCC-11111-2222222222222");
        params.put("response_format", "json");
        params.put("sdk", "server");
        params.put("site_id", siteId);
        params.put("user_id", "10000000001");
 
        return "&" + params.entrySet().stream()
                .map(p -> URLParamEncoder.encode(p.getKey()) + "=" + URLParamEncoder.encode(p.getValue()))
                .reduce((p1, p2) -> p1 + "&" + p2)
                .orElse("");
    }
 
    private static String createStringToSign(String httpMethod,
                                             String host,
                                             String path,
                                             String encodedUrlParams,
                                             String timestamp, String postParams) {
        return httpMethod.equals("GET") ?
                httpMethod + "\n" + host + "\n" + path + "?" + encodedUrlParams + "\n" + timestamp + "\n" + postParams :
                httpMethod + "\n" + host + "\n" + path + "\n" + timestamp + "\n" + postParams;
    }
 
    private static String generateSignature(String urlStringToSign, String key) throws NoSuchAlgorithmException,
            InvalidKeyException, UnsupportedEncodingException {
        Mac sha256_HMAC = Mac.getInstance(HMAC_SHA256_ALGORITHM);
        SecretKeySpec secret_key = new SecretKeySpec(key.getBytes(), HMAC_SHA256_ALGORITHM);
        sha256_HMAC.init(secret_key);
        return Base64.encodeBase64URLSafeString(sha256_HMAC.doFinal(urlStringToSign.getBytes()));
    }
}

{
    "success": true,
    "site_event_type": "install",
    "tracking_id": "3c225547069f297b3a0ed4264aac36b3",
    "advertiser_ref_id": null,
    "log_id": "b2f3ce90d42e12e895-20140709-877",
    "message": [ ],
    "log_action": true
}

{
    "success": false,
    "site_event_type": "install",
    "tracking_id": "b34ce0f6d1578958972c30b6a35882fc",
    "advertiser_ref_id": null,
    "log_id": "7d6d2f08db789514af-20140709-877",
    "message": [
        "Duplicate request detected."
    ]
}