oauth.signpost.http.HttpRequest Java Examples

@Override
public String sign(HttpRequest request, HttpParameters requestParams)
    throws OAuthMessageSignerException {

  final OAuthRsaSigner signer = new OAuthRsaSigner();
  final byte[] privateBytes = Base64.decodeBase64(getConsumerSecret());
  final PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateBytes);

  try {
    signer.privateKey = KeyFactory.getInstance("RSA").generatePrivate(keySpec);
    final String signatureBaseString = new SignatureBaseString(request, requestParams).generate();
    return signer.computeSignature(signatureBaseString);
  } catch (GeneralSecurityException e) {
    throw new OAuthMessageSignerException(e);
  }
}
 

@Override
public void processHttpMessage(int toolFlag, boolean messageIsRequest, IHttpRequestResponse messageInfo)
{
	if (messageIsRequest && shouldSign(messageInfo))
	{
		HttpRequest req = new BurpHttpRequestWrapper(messageInfo);
		OAuthConsumer consumer = new DefaultOAuthConsumer(
				OAuthConfig.getConsumerKey(),
				OAuthConfig.getConsumerSecret());
		consumer.setTokenWithSecret(OAuthConfig.getToken(),
				OAuthConfig.getTokenSecret());
		try {
			consumer.sign(req);
		} catch (OAuthException oae) {
			oae.printStackTrace();
		}
	}
}
 

@Override
protected HttpRequest wrap(Object request) {
  if (!(request instanceof Request)) {
    throw new IllegalArgumentException(
        "Accepts only requests of type " + Request.class.getCanonicalName());
  }
  return new RequestAdapter((Request) request);
}
 

@Override
protected void closeConnection(HttpRequest request, HttpResponse response) throws Exception {
    if (response != null) {
        Response r = (Response) response.unwrap();
        r.close();
    }
}
 

@Override
protected HttpRequest wrap(Object request) {
    if (!(request instanceof Request)) {
        throw new IllegalArgumentException("This consumer expects requests of type " + Request.class.getCanonicalName());
    }
    return new OkHttpRequestAdapter((Request) request);
}
 

@Ignore
public static HttpRequest reqWrapForTestInput(int num) throws IOException {
	RandomAccessFile f = new RandomAccessFile(String.format("test-inputs/%d.txt", num), "r");
	final byte[] req = new byte[(int)f.length()];
	f.read(req);
	IHttpRequestResponse request = new MockRequest(req);
	HttpRequest reqWrap = new BurpHttpRequestWrapper(request);
	request.setHttpService(new MockService(reqWrap.getHeader("Host")));
	return reqWrap;
}
 

@Test
public void testGetMessagePayload() throws IOException {
	HttpRequest hr;
	hr = reqWrapForTestInput(1);
	assertEquals(0, hr.getMessagePayload().available());
	hr = reqWrapForTestInput(2);
	final InputStream is = hr.getMessagePayload();
	final byte[] buf = new byte[is.available()];
	assertEquals(buf.length, is.read(buf));
	assertEquals(SOAP_BODY, new String(buf));
}
 

@Test
public void testSignature() throws Exception {
	HttpRequest hr = reqWrapForTestInput(1);
	OAuthConsumer consumer = new DefaultOAuthConsumer("1234", "5678");
	consumer.setTokenWithSecret("9ABC", "DEF0");
	consumer.sign(hr);
}
 

@Test
public void testUpdateHeader() throws IOException {
	HttpRequest hr = reqWrapForTestInput(1);
	assertEquals(hr.getHeader(UPDATE_HEADER_NAME), UPDATE_HEADER_OLD);
	hr.setHeader(UPDATE_HEADER_NAME, UPDATE_HEADER_VALUE);
	assertEquals(hr.getHeader(UPDATE_HEADER_NAME), UPDATE_HEADER_VALUE);
	assertEquals(hr.getHeader("Connection"), "Keep-Alive"); // next one
}
 

@Test
public void testInsertHeader() throws IOException {
	HttpRequest hr = reqWrapForTestInput(1);
	assertEquals(hr.getHeader(INSERT_HEADER_NAME), null);
	hr.setHeader(INSERT_HEADER_NAME, INSERT_HEADER_VALUE);
	assertEquals(hr.getHeader(INSERT_HEADER_NAME), INSERT_HEADER_VALUE);
}
 

@Test
public void testGetHeader() throws IOException {
	HttpRequest hr;
	hr = reqWrapForTestInput(1);
	assertEquals(hr.getHeader("Accept"), "application/json");
	assertEquals(hr.getHeader("Host"), "silentsignal.hu");
	assertEquals(hr.getHeader("Connection"), "Keep-Alive");
	assertEquals(hr.getHeader("User-Agent"), "Silent Signal");
	assertEquals(hr.getHeader("Non-Existent"), null);
	hr = reqWrapForTestInput(2);
	assertEquals(hr.getHeader("Host"), "weirdport.foo.bar:8081");
}
 

@Test
public void testGetContentType() throws IOException {
	HttpRequest hr;
	hr = reqWrapForTestInput(1);
	assertEquals(hr.getContentType(), null);
	hr = reqWrapForTestInput(2);
	assertEquals(hr.getContentType(), "text/xml; charset=utf-8");
}
 

@Test
public void testGetMethod() throws IOException {
	HttpRequest hr;
	hr = reqWrapForTestInput(1);
	assertEquals(hr.getMethod(), "GET");
	hr = reqWrapForTestInput(2);
	assertEquals(hr.getMethod(), "POST");
}
 

@Override
protected HttpRequest wrap(Object request) {
    if (!(request instanceof WSRequest)) {
        throw new IllegalArgumentException("WSOAuthConsumer expects requests of type play.libs.WS.WSRequest");
    }
    return new WSRequestAdapter((WSRequest)request);
}
 

@Override
protected HttpRequest wrap(Object request) {
    if (!(request instanceof Request)) {
        throw new IllegalArgumentException("This consumer expects requests of type " + Request.class.getCanonicalName());
    }
    return new OkHttpRequestAdapter((Request) request);
}
 

@Override
public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();
    try {
        HttpRequest httpRequest = consumer.sign(request);
        Request authenticateRequest = (Request) httpRequest.unwrap();
        return chain.proceed(authenticateRequest);
    } catch (OAuthException e) {
        Log.e(LOG_TAG, "Error " + e.getMessage());
        throw new IOException("Could not sign request", e);
    }
}
 

@Override
protected HttpRequest wrap(Object request) {
    if (!(request instanceof Request)) {
        throw new IllegalArgumentException("This consumer expects requests of type " + Request.class.getCanonicalName());
    }
    return new OkHttpRequestAdapter((Request) request);
}
 

@Override
public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();
    try {
        HttpRequest httpRequest = consumer.sign(request);
        Request authenticateRequest = (Request) httpRequest.unwrap();
        return chain.proceed(authenticateRequest);
    } catch (OAuthException e) {
        Log.e(LOG_TAG, "Error " + e.getMessage());
        throw new IOException("Could not sign request", e);
    }
}
 

@Override
protected HttpRequest createRequest(String endpointUrl) throws Exception {
    final Request.Builder builder =
            new Request.Builder()
                    .url(endpointUrl)
                    .post(Util.EMPTY_REQUEST);
    if (endpointUrl.contains(Config.ACCESS_TOKEN_URL)) {
        final MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
        final String body =
                String.format("x_auth_mode=%s&x_auth_password=%s&x_auth_username=%s",
                        Config.X_AUTH_MODE, Config.X_AUTH_PASSWORD, Config.X_AUTH_USERNAME);
        builder.post(RequestBody.create(mediaType, body));
    }
    return new OkHttpRequestAdapter(builder.build());
}
 

@Test
public void testGetRequestUrl() throws IOException {
	HttpRequest hr = reqWrapForTestInput(1);
	assertEquals(hr.getRequestUrl(), "http://silentsignal.hu:1337/foo/bar");
}
 

@Override
protected HttpResponse sendRequest(HttpRequest request) throws Exception {
    Response response = okHttpClient.newCall((Request) request.unwrap()).execute();
    return new OkHttpResponseAdapter(response);
}
 

@Override
protected HttpRequest createRequest(String endpointUrl) throws Exception {
    Request request = new Request.Builder().url(endpointUrl).build();
    return new OkHttpRequestAdapter(request);
}
 

@Override
protected HttpResponse sendRequest(HttpRequest request) throws Exception {
    Response response = okHttpClient.newCall((Request) request.unwrap()).execute();
    return new OkHttpResponseAdapter(response);
}
 

@Override
protected HttpRequest wrap(Object request) {
    return new OkRequestAdapter((Request) request);
}