Java OAuthMessageSignerException类代码示例

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
@Override
public HttpRequest sign(HttpRequest request, String key, String secret) throws LtiSigningException {
    CommonsHttpOAuthConsumer signer = new CommonsHttpOAuthConsumer(key, secret);
    try {
        String body = getRequestBody(request);
        String bodyHash = new String(Base64.encodeBase64(md.digest(body.getBytes())));

        HttpParameters params = new HttpParameters();
        params.put("oauth_body_hash", URLEncoder.encode(bodyHash, "UTF-8"));
        signer.setAdditionalParameters(params);

        signer.sign(request);
    } catch (OAuthMessageSignerException|OAuthExpectationFailedException|OAuthCommunicationException|IOException e) {
        throw new LtiSigningException("Exception encountered while singing Lti request...", e);
    }
    return request;
}
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
@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);
  }
}
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
@Test
public void retrieveAccessToken_success() throws OAuthCommunicationException, OAuthExpectationFailedException, OAuthNotAuthorizedException, OAuthMessageSignerException {
    Uri uri = mock(Uri.class);
    String verifier = "some verifier";
    when(uri.getQueryParameter(OAuth.OAUTH_VERIFIER)).thenReturn(verifier);

    String userTokenString = "some token";
    when(okHttpOAuthConsumer.getToken()).thenReturn(userTokenString);

    String userTokenSecretString = "some secret token";
    when(okHttpOAuthConsumer.getTokenSecret()).thenReturn(userTokenSecretString);


    TestSubscriber testSubscriber = new TestSubscriber();
    oAuthInteractor.retrieveAccessToken(uri)
            .subscribe(testSubscriber);

    testSubscriber.assertCompleted();

    verify(okHttpOAuthProvider, times(1)).retrieveAccessToken(okHttpOAuthConsumer, verifier);
    verify(userToken, times(1)).set(userTokenString);
    verify(userTokenSecret, times(1)).set(userTokenSecretString);
}
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
/**
 * This method request a request token and saves the received authUrl in the
 * global variable
 * 
 * @return true if success; false otherwise
 */
public ResponseCode getRequestToken() {
    logger.entry();

    if (isAuthorized) {
        return logger.exit(ResponseCode.APPLICATION_ALREADY_AUTHORIZED);
    }

    mProvider = new DefaultOAuthProvider(mServer.getRequestUrl(), mServer.getAccessUrl(),
            mServer.getAuthorizationUrl());
    try {
        authUrl = mProvider.retrieveRequestToken(mConsumer, "http://studip-client.danner-web.de/callback");
    } catch (OAuthMessageSignerException | OAuthNotAuthorizedException | OAuthExpectationFailedException
            | OAuthCommunicationException e) {
        logger.debug("Unable to fetch oauth_request_token");
        return logger.exit(ResponseCode.SERVER_NOT_REACHABLE);
    }

    return logger.exit(ResponseCode.SUCCESS);
}
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
public ResponseCode getAccessToken() {

        if (isAuthorized) {
            return logger.exit(ResponseCode.APPLICATION_ALREADY_AUTHORIZED);
        }

        if (mProvider != null) {
            try {
                mProvider.retrieveAccessToken(mConsumer, OAuth.OUT_OF_BAND);

                mServer.setAccessToken(mConsumer.getToken());
                mServer.setAccessTokenSecret(mConsumer.getTokenSecret());

                isAuthorized = true;

            } catch (OAuthMessageSignerException | OAuthNotAuthorizedException | OAuthExpectationFailedException
                    | OAuthCommunicationException e) {
                logger.debug("Unable to fetch oauth_access_token");
                return logger.exit(ResponseCode.APPLICATION_NOT_AUTHORIZED);
            }
        }
        return logger.exit(ResponseCode.SUCCESS);
    }
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
/**
 * Helper method to download and show all news within the given range.
 * 
 * @param range
 * @return 0 if success, otherwise error code
 */
private int downloadAndShowNews(NewsRange range) {
	HttpURLConnection connection = null;
	try {
		connection = con.get(getUnreadNewsFromRange(range));
	} catch (OAuthNotAuthorizedException | OAuthMessageSignerException | OAuthExpectationFailedException
			| OAuthCommunicationException e) {
		e.printStackTrace();
	}
	if (connection == null) {
		return 500;
	}

	List<News> newsList = JSONParserUtil.parse(connection, News.class);
	if (newsList != null) {
		for (News news : newsList) {
			SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy");
			Date dt = new Date(Long.valueOf(news.date) * 1000);
			String time = sdf.format(dt);
			context.appendPopup(new TextPluginMessage(news.topic + " (" + news.author + " " + time + ")",
					news.body, new NewsListener(news)));
		}
	}
	return 0;
}
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
@Override
public String sign(HttpRequest request, HttpParameters requestParams) throws OAuthMessageSignerException {
    byte[] decodedPrivateKey;
    try {
        decodedPrivateKey = Base64.decode(getConsumerSecret());
        String baseString = new SignatureBaseString(request, requestParams).generate();
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_TYPE);
        EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedPrivateKey);
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        signature.initSign(privateKey);
        signature.update(baseString.getBytes());
        byte[] rsasha1 = signature.sign();
        return Base64.encode(rsasha1);
    } catch (IOException | NoSuchAlgorithmException | InvalidKeyException | InvalidKeySpecException | SignatureException e) {
        throw new OAuthMessageSignerException(e);
    }
}
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
private HttpStreamResponse executePostJsonStreamingResponse(HttpEntityEnclosingRequestBase requestBase,
    String jsonBody,
    Map<String, String> headers) throws HttpClientException {
    try {
        setRequestHeaders(headers, requestBase);
        requestBase.setEntity(new StringEntity(jsonBody, ContentType.APPLICATION_JSON));
        requestBase.addHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON);
        return executeStream(requestBase);
    } catch (IOException | UnsupportedCharsetException | OAuthCommunicationException | OAuthExpectationFailedException |
        OAuthMessageSignerException e) {
        String trimmedMethodBody = (jsonBody.length() > JSON_POST_LOG_LENGTH_LIMIT)
            ? jsonBody.substring(0, JSON_POST_LOG_LENGTH_LIMIT) : jsonBody;
        throw new HttpClientException("Error executing " + requestBase.getMethod() + " request " +
            "to " + clientPathToString(requestBase.getURI().getPath()) + " body:" + trimmedMethodBody, e);
    }
}
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
private HttpStreamResponse executeStream(HttpRequestBase requestBase) throws OAuthMessageSignerException,
    OAuthExpectationFailedException,
    OAuthCommunicationException,
    IOException {
    applyHeadersCommonToAllRequests(requestBase);
    activeCount.incrementAndGet();
    CloseableHttpResponse response = client.execute(requestBase);
    StatusLine statusLine = response.getStatusLine();

    int status = statusLine.getStatusCode();
    if (status < 200 || status >= 300) {
        activeCount.decrementAndGet();
        HttpClientUtils.closeQuietly(response);
        requestBase.reset();
        throw new IOException("Bad status : " + statusLine);
    }

    return new HttpStreamResponse(statusLine.getStatusCode(),
        statusLine.getReasonPhrase(),
        response,
        response.getEntity().getContent(),
        requestBase,
        activeCount);
}
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
public static String getAuthoriseAppUrl(Context context)
		throws OAuthMessageSignerException, OAuthNotAuthorizedException,
		OAuthExpectationFailedException, OAuthCommunicationException {

	/**
	 * You will want to set customProtocol to something unique to avoid
	 * having Android give the user more than one app to pick from to handle
	 * the oauth callback. A good option would be to use something derived
	 * from your package name.
	 */
	String customProtocol = context.getResources().getString(
			R.string.customAppProtocol);

	return provider.retrieveRequestToken(consumer, customProtocol
			+ "://oauth");
}
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
private static void requestObjectApi( OAuthConsumer consumer ) throws MalformedURLException, IOException, OAuthMessageSignerException,
  OAuthExpectationFailedException, OAuthCommunicationException, UnsupportedEncodingException
{

  LOGGER.info( "#################################################################################################" );

  URL url =
    new URL( "http://sandbox.immobilienscout24.de/restapi/api/search/v1.0/searcher/abc" );

  HttpURLConnection apiRequest = (HttpURLConnection) url.openConnection();

  consumer.sign( apiRequest );
  LOGGER.info( "Sending request..." );

  apiRequest.connect();
  LOGGER.info( "Expiration "+apiRequest.getExpiration() );
  LOGGER.info( "Timeout "+apiRequest.getConnectTimeout() );
  LOGGER.info( "URL "+apiRequest.getURL() );
  LOGGER.info( "Method "+apiRequest.getRequestMethod() );

  LOGGER.info( "Response: "+apiRequest.getResponseCode()+" "
    +apiRequest.getResponseMessage() );

  LOGGER.info( "#################################################################################################" );
}
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
public ContentExchange stream(ContentExchange ex, Symbol... symbols) throws ModelException
{
	OAuthConsumer consumer = new JettyOAuthConsumer(ForemanConstants.API_KEY.toString(), ForemanConstants.API_SECRET.toString());
	consumer.setTokenWithSecret(ForemanConstants.ACCESS_TOKEN.toString(), ForemanConstants.ACCESS_TOKEN_SECRET.toString());

	ex.setMethod(Verb.GET.name());
	ex.setURL(APICall.getStreamingQuote(ResponseFormat.XML) + getParameters(symbols));

	// sign the request
	try
	{
		consumer.sign(ex);
		client.send(ex);
	}
	catch (IOException | OAuthMessageSignerException | OAuthExpectationFailedException | OAuthCommunicationException e)
	{
		throw new ModelException("Sent Exchange to Client", e);
	}

	return ex;
}
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
@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);
	}
}
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
@Test
public void prepareConnection_throwsExceptionWhenSigningFailed() throws Exception {
	OAuthConsumer someCrashingConsumer = mock(OAuthConsumer.class);
	when(someCrashingConsumer.sign(any(Object.class))).thenThrow(new OAuthMessageSignerException("could not sign :("));

	requestFactory = new OAuthSignedClientHttpRequestFactory(someCrashingConsumer);

	assertThatThrownBy(() -> requestFactory.prepareConnection(connectionTo("http://some-domain.com"), "GET"))
			.hasMessage("Could not sign request to http://some-domain.com")
			.hasCauseExactlyInstanceOf(OAuthMessageSignerException.class);
}
 

import oauth.signpost.exception.OAuthMessageSignerException; //导入依赖的package包/类
@Test
public void retrieveRequestToken_success() throws OAuthCommunicationException, OAuthExpectationFailedException, OAuthNotAuthorizedException, OAuthMessageSignerException {
    String token = "some token";
    when(okHttpOAuthProvider.retrieveRequestToken(any(), anyString())).thenReturn(token);

    TestSubscriber<String> testSubscriber = new TestSubscriber<>();
    oAuthInteractor.retrieveRequestToken()
            .subscribe(testSubscriber);

    testSubscriber.assertValue(token);
    verify(okHttpOAuthProvider, times(1)).retrieveRequestToken(okHttpOAuthConsumer, ApiConstants.OAUTH_CALLBACK);
}