Evernoteにアクセスする その４ HMAC-SHA1編

ここまでサンプルを元にEvernoteにアクセスしてきましたが、
SimpleOAuthRequestの中身を見てOAuthアクセスへの理解を
深めておきましょう。。。。って思ったんですけど、PLANTEXTでアクセスしているので
HMAC-SHA1でアクセスしてみましょう。

以下が元ソースです。
見られる場合は展開してください。

+ expand sourceview plainprint?

1. /** 
2.  * Copyright 2008 by EverNote Corporation.  All rights reserved. 
3.  */  
4.   
5. package com.evernote.oauth.consumer;  
6.   
7. import java.io.BufferedReader;  
8. import java.io.IOException;  
9. import java.io.InputStreamReader;  
10. import java.net.HttpURLConnection;  
11. import java.net.URL;  
12. import java.net.URLDecoder;  
13. import java.net.URLEncoder;  
14. import java.util.HashMap;  
15. import java.util.Map;  
16. import java.util.Random;  
17.   
18. /** 
19.  * This is a very simple implementation of an OAuth consumer request which can 
20.  * be used to ask an OAuth service provider for either a Request Token or 
21.  * an Access Token.  It only handles PLAINTEXT authentication, and it only goes 
22.  * over a GET transport.  As a result, it should only be used over SSL. 
23.  *  
24.  * @author Dave Engberg 
25.  */  
26. public class SimpleOAuthRequest {  
27.   
28.   /** 
29.    * Random number generator for creating OAuth nonces 
30.    */  
31.   private static final Random random = new Random();  
32.     
33.   /** 
34.    * The URL of the OAuth service Provider that we should hit to request a 
35.    * token. 
36.    */  
37.   private String providerUrl;  
38.   
39.   /** 
40.    * A mapping containing all of the OAuth parameters that will be passed in 
41.    * the reply. 
42.    */  
43.   private Map<string, string=""> parameters = new HashMap<string, string="">();  
44.     
45.   /** 
46.    * Constructs a request object that can be used to make token requests from 
47.    * an OAuth provider. 
48.    *  
49.    * @param providerUrl  the base URL to request a Request or Access token 
50.    * @param consumerKey  the OAuth consumer key, given by the Service Provider 
51.    * @param consumerSecret  the OAuth consumer secret, given by the Provider 
52.    * @param tokenSecret  if non-null, this is the previous oauth_token_secret 
53.    *   that should be used in signing this request.  If null, this will assume 
54.    *   that this message does not include a token secret in its signature 
55.    */  
56.   public SimpleOAuthRequest(String providerUrl, String consumerKey,  
57.       String consumerSecret, String tokenSecret) {  
58.     this.providerUrl = providerUrl;  
59.     setParameter("oauth_consumer_key", consumerKey);  
60.     String signature = consumerSecret + "&";  
61.     if (tokenSecret != null) {  
62.       signature += tokenSecret;  
63.     }  
64.     setParameter("oauth_signature", signature);  
65.     setParameter("oauth_signature_method", "PLAINTEXT");  
66.     setParameter("oauth_timestamp",  
67.         Long.toString(System.currentTimeMillis() / 1000));  
68.     setParameter("oauth_nonce",  
69.         Long.toHexString(random.nextLong()));  
70.     setParameter("oauth_version", "1.0");  
71.   }  
72.     
73.   /** 
74.    * Sets one of the query string parameters for the request that will be 
75.    * made to the OAuth provider.  The value will be URL encoded before adding 
76.    * to the URL. 
77.    *  
78.    * @param name  the name of the parameter to be set 
79.    * @param value  the string value, unencoded 
80.    */  
81.   public void setParameter(String name, String value) {  
82.     parameters.put(name, value);  
83.   }  
84.     
85.   /** 
86.    * Encodes this request as a single URL that can be opened. 
87.    */  
88.   public String encode() throws IOException {  
89.     StringBuilder sb = new StringBuilder();  
90.     sb.append(providerUrl);  
91.     boolean firstParam = providerUrl.indexOf('?') < 0;  
92.     for (Map.Entry<string, string=""> parameter : parameters.entrySet()) {  
93.       if (firstParam) {  
94.         sb.append('?');  
95.         firstParam = false;  
96.       } else {  
97.         sb.append('&');  
98.       }  
99.       sb.append(parameter.getKey());  
100.       sb.append('=');  
101.       sb.append(URLEncoder.encode(parameter.getValue(), "UTF-8"));  
102.     }  
103.     return sb.toString();  
104.   }  
105.   
106.   /** 
107.    * Sends the request to the OAuth Provider, and returns the set of reply 
108.    * parameters, mapped from name to decoded value. 
109.    * 
110.    * @throws IOException  if a problem occurs making the request or getting the 
111.    *   reply. 
112.    */  
113.   public Map<string,string> sendRequest() throws IOException {  
114.   
115.     HttpURLConnection connection =  
116.       (HttpURLConnection)(new URL(encode())).openConnection();  
117.     int responseCode = connection.getResponseCode();  
118.     if (responseCode != HttpURLConnection.HTTP_OK) {  
119.       throw new IOException("Server returned error code: " + responseCode +  
120.           " " + connection.getResponseMessage());  
121.     }  
122.     BufferedReader bufferedReader = new BufferedReader(  
123.         new InputStreamReader(connection.getInputStream()));  
124.     String result = bufferedReader.readLine();  
125.     Map<string,string> responseParameters = new HashMap<string,string>();  
126.     for (String param : result.split("&")) {  
127.       int equalsAt = param.indexOf('=');  
128.       if (equalsAt > 0) {  
129.         String name = param.substring(0, equalsAt);  
130.         String value =  
131.           URLDecoder.decode(param.substring(equalsAt + 1), "UTF-8");  
132.         responseParameters.put(name, value);  
133.       }  
134.     }  
135.     return responseParameters;  
136.   }  
137.     
138. }  
139. </string,string></string,string></string,string></string,></string,></string,>  

/**
 * Copyright 2008 by EverNote Corporation.  All rights reserved.
 */

package com.evernote.oauth.consumer;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

/**
 * This is a very simple implementation of an OAuth consumer request which can
 * be used to ask an OAuth service provider for either a Request Token or
 * an Access Token.  It only handles PLAINTEXT authentication, and it only goes
 * over a GET transport.  As a result, it should only be used over SSL.
 * 
 * @author Dave Engberg
 */
public class SimpleOAuthRequest {

  /**
   * Random number generator for creating OAuth nonces
   */
  private static final Random random = new Random();
  
  /**
   * The URL of the OAuth service Provider that we should hit to request a
   * token.
   */
  private String providerUrl;

  /**
   * A mapping containing all of the OAuth parameters that will be passed in
   * the reply.
   */
  private Map parameters = new HashMap();
  
  /**
   * Constructs a request object that can be used to make token requests from
   * an OAuth provider.
   * 
   * @param providerUrl  the base URL to request a Request or Access token
   * @param consumerKey  the OAuth consumer key, given by the Service Provider
   * @param consumerSecret  the OAuth consumer secret, given by the Provider
   * @param tokenSecret  if non-null, this is the previous oauth_token_secret
   *   that should be used in signing this request.  If null, this will assume
   *   that this message does not include a token secret in its signature
   */
  public SimpleOAuthRequest(String providerUrl, String consumerKey,
      String consumerSecret, String tokenSecret) {
    this.providerUrl = providerUrl;
    setParameter("oauth_consumer_key", consumerKey);
    String signature = consumerSecret + "&";
    if (tokenSecret != null) {
      signature += tokenSecret;
    }
    setParameter("oauth_signature", signature);
    setParameter("oauth_signature_method", "PLAINTEXT");
    setParameter("oauth_timestamp",
        Long.toString(System.currentTimeMillis() / 1000));
    setParameter("oauth_nonce",
        Long.toHexString(random.nextLong()));
    setParameter("oauth_version", "1.0");
  }
  
  /**
   * Sets one of the query string parameters for the request that will be
   * made to the OAuth provider.  The value will be URL encoded before adding
   * to the URL.
   * 
   * @param name  the name of the parameter to be set
   * @param value  the string value, unencoded
   */
  public void setParameter(String name, String value) {
    parameters.put(name, value);
  }
  
  /**
   * Encodes this request as a single URL that can be opened.
   */
  public String encode() throws IOException {
    StringBuilder sb = new StringBuilder();
    sb.append(providerUrl);
    boolean firstParam = providerUrl.indexOf('?') < 0;
    for (Map.Entry parameter : parameters.entrySet()) {
      if (firstParam) {
        sb.append('?');
        firstParam = false;
      } else {
        sb.append('&');
      }
      sb.append(parameter.getKey());
      sb.append('=');
      sb.append(URLEncoder.encode(parameter.getValue(), "UTF-8"));
    }
    return sb.toString();
  }

  /**
   * Sends the request to the OAuth Provider, and returns the set of reply
   * parameters, mapped from name to decoded value.
   *
   * @throws IOException  if a problem occurs making the request or getting the
   *   reply.
   */
  public Map sendRequest() throws IOException {

    HttpURLConnection connection =
      (HttpURLConnection)(new URL(encode())).openConnection();
    int responseCode = connection.getResponseCode();
    if (responseCode != HttpURLConnection.HTTP_OK) {
      throw new IOException("Server returned error code: " + responseCode +
          " " + connection.getResponseMessage());
    }
    BufferedReader bufferedReader = new BufferedReader(
        new InputStreamReader(connection.getInputStream()));
    String result = bufferedReader.readLine();
    Map responseParameters = new HashMap();
    for (String param : result.split("&")) {
      int equalsAt = param.indexOf('=');
      if (equalsAt > 0) {
        String name = param.substring(0, equalsAt);
        String value =
          URLDecoder.decode(param.substring(equalsAt + 1), "UTF-8");
        responseParameters.put(name, value);
      }
    }
    return responseParameters;
  }
  
}

これをHMAC-SHA1で処理を行う場合は、oauth_signatureの指定に
・HTTPメソッド
・リクエストURL
・リクエストパタメータ
これらをURLエンコードして、＆で結合してHMAC-SHA1で16進のダイジェスト値を作って
Base64エンコード後、URLエンコードした値をoauth_signatureに指定します。

オリジナルでEvernoteRequestクラスを作成してアクセスしてみましょう。
※動作確認用なので汚いのは許して＞＜

以下がHMAC-SHA1でアクセスしたソース

+ expand sourceview plainprint?

1. /** 
2.  * Copyright 2008 by EverNote Corporation.  All rights reserved. 
3.  */  
4.   
5. package jp.co.ziro.evernote.controller;  
6.   
7. import java.io.BufferedReader;  
8. import java.io.IOException;  
9. import java.io.InputStreamReader;  
10. import java.io.UnsupportedEncodingException;  
11. import java.net.HttpURLConnection;  
12. import java.net.URL;  
13. import java.net.URLDecoder;  
14. import java.net.URLEncoder;  
15. import java.security.InvalidKeyException;  
16. import java.security.NoSuchAlgorithmException;  
17. import java.util.HashMap;  
18. import java.util.Map;  
19. import java.util.Random;  
20. import java.util.TreeMap;  
21. import java.util.logging.Logger;  
22.   
23. import javax.crypto.Mac;  
24. import javax.crypto.spec.SecretKeySpec;  
25.   
26. import org.apache.commons.codec.binary.Base64;  
27. import org.slim3.util.ApplicationMessage;  
28.   
29. /** 
30.  * This is a very simple implementation of an OAuth consumer request which can 
31.  * be used to ask an OAuth service provider for either a Request Token or an 
32.  * Access Token. It only handles PLAINTEXT authentication, and it only goes over 
33.  * a GET transport. As a result, it should only be used over SSL. 
34.  *  
35.  * @author Dave Engberg 
36.  */  
37. public class EvernoteRequest {  
38.   
39.     @SuppressWarnings("unused")  
40.     private static Logger logger = Logger.getLogger(EvernoteRequest.class.getName());  
41.  private static final String consumerKey = ApplicationMessage  
42.    .get("evernote.api.key");  
43.  private static final String consumerSecret = ApplicationMessage  
44.    .get("evernote.api.secret");  
45.  private static final String urlBase = ApplicationMessage  
46.    .get("evernote.api.baseUrl");  
47.  private static final String requestUrl = urlBase  
48.    + ApplicationMessage.get("evernote.api.requestTokenUrl");  
49.  /** 
50.   * ベースのURL 
51.   * @return 
52.   */  
53.  public static String getBaseUrl() {  
54.   return urlBase;  
55.  }  
56.   
57.  /** 
58.   * Random number generator for creating OAuth nonces 
59.   */  
60.  private static final Random random = new Random();  
61.   
62.  /** 
63.   * A mapping containing all of the OAuth parameters that will be passed in 
64.   * the reply. 
65.   */  
66.  private Map<string, string=""> parameters = new TreeMap<string, string="">();  
67.   
68.  /** 
69.   * Constructs a request object that can be used to make token requests from 
70.   * an OAuth provider. 
71.   */  
72.  public EvernoteRequest() {  
73.   setParameter("oauth_consumer_key", consumerKey);  
74.   //暗号化を行う  
75.   setParameter("oauth_signature_method", "HMAC-SHA1");  
76.   setParameter("oauth_timestamp", getTimestamp());  
77.   setParameter("oauth_nonce", Long.toHexString(random.nextLong()));  
78.   setParameter("oauth_version", "1.0");  
79.  }  
80.  /** 
81.   * タイムスタンプを作成 
82.   * @return 
83.   */  
84.  private String getTimestamp() {  
85.   return Long.toString(System.currentTimeMillis() / 1000);  
86.  }  
87.   
88.  /** 
89.   * Sets one of the query string parameters for the request that will be made 
90.   * to the OAuth provider. The value will be URL encoded before adding to the 
91.   * URL. 
92.   *  
93.   * @param name 
94.   *            the name of the parameter to be set 
95.   * @param value 
96.   *            the string value, unencoded 
97.   */  
98.  public void setParameter(String name, String value) {  
99.   parameters.put(name, value);  
100.  }  
101.   
102.  /** 
103.   * Encodes this request as a single URL that can be opened. 
104.   */  
105.  private String encode() {  
106.   return requestUrl + "?" + join();  
107.  }  
108.   
109.  /** 
110.   * HTTP引数の連結 
111.   * @return 
112.   */  
113.  private String join() {  
114.   StringBuilder sb = new StringBuilder();  
115.   boolean firstParam = true;  
116.   for (Map.Entry<string, string=""> parameter : parameters.entrySet()) {  
117.    if (firstParam) {  
118.     firstParam = false;  
119.    } else {  
120.     sb.append('&');  
121.    }  
122.    sb.append(parameter.getKey());  
123.    sb.append('=');  
124.    try {  
125.     sb.append(URLEncoder.encode(parameter.getValue(), CHARSET));  
126.    } catch (UnsupportedEncodingException e) {  
127.     throw new RuntimeException("エンコード時の例外", e);  
128.    }  
129.   }  
130.   return sb.toString();  
131.  }  
132.   
133.  /** 
134.   * 文字コード 
135.   */  
136.  private static final String CHARSET = "UTF-8";  
137.  /** 
138.   * キー作成用のGETメソッド名 
139.   */  
140.  private static final String REQUEST_METHOD = "GET";  
141.   
142.  /** 
143.   * Sends the request to the OAuth Provider, and returns the set of reply 
144.   * parameters, mapped from name to decoded value. 
145.   *  
146.   * @throws IOException 
147.   *             if a problem occurs making the request or getting the reply. 
148.   */  
149.  public Map<string, string=""> sendRequest(String tokenSecret) throws IOException {  
150.   // 署名対象のテキストを作成  
151.   String secret = consumerSecret + "&";  
152.   if (tokenSecret != null) {  
153.    secret += tokenSecret;  
154.   }  
155.   
156.   String hmac = "HmacSHA1";  
157.     
158.   String encodeUrl  = URLEncoder.encode(requestUrl,CHARSET);  
159.   String encodeJoin = URLEncoder.encode(join(),CHARSET);  
160.   
161.   String signatureBaseString = REQUEST_METHOD + "&" + encodeUrl + "&" + encodeJoin;  
162.   logger.info(signatureBaseString);  
163.   
164.         byte[] secretyKeyBytes = secret.getBytes(CHARSET);  
165.      SecretKeySpec secretKeySpec =  new SecretKeySpec(secretyKeyBytes,hmac);  
166.      Mac mac;  
167.   try {  
168.    mac = Mac.getInstance(hmac);  
169.    mac.init(secretKeySpec);  
170.   } catch (NoSuchAlgorithmException e1) {  
171.    throw new RuntimeException("暗号化インスタンス取得失敗",e1);  
172.   } catch (InvalidKeyException e1) {  
173.    throw new RuntimeException("暗号化インスタンス取得失敗",e1);  
174.   }  
175.        
176.         String signature = null;  
177.         byte[] data;  
178.         byte[] rawHmac;  
179.         try {  
180.             data = signatureBaseString.getBytes(CHARSET);  
181.             rawHmac = mac.doFinal(data);  
182.             Base64 encoder = new Base64();  
183.             signature = new String(encoder.encode(rawHmac));  
184.         } catch (UnsupportedEncodingException e) {  
185.             throw new RuntimeException(CHARSET + " is unsupported!", e);  
186.         }  
187.   setParameter("oauth_signature", signature);  
188.   
189.   HttpURLConnection connection = (HttpURLConnection) (new URL(encode())).openConnection();  
190.   int responseCode = connection.getResponseCode();  
191.   // リクエストが正常じゃない場合  
192.   if (responseCode != HttpURLConnection.HTTP_OK) {  
193.    throw new IOException("Server returned error code: " + responseCode  
194.      + " " + connection.getResponseMessage());  
195.   }  
196.   return createResponseMap(connection);  
197.  }  
198.   
199.  /** 
200.   * レスポンスの値を取得 
201.   *  
202.   * @param connection 
203.   * @return 
204.   */  
205.  private Map<string, string=""> createResponseMap(HttpURLConnection connection) {  
206.   
207.   BufferedReader bufferedReader;  
208.   String result;  
209.   try {  
210.    bufferedReader = new BufferedReader(new InputStreamReader(  
211.      connection.getInputStream()));  
212.    result = bufferedReader.readLine();  
213.   } catch (IOException e) {  
214.    throw new RuntimeException("読み込み時の例外", e);  
215.   }  
216.   
217.   Map<string, string=""> responseParameters = new HashMap<string, string="">();  
218.   for (String param : result.split("&")) {  
219.    int equalsAt = param.indexOf('=');  
220.    if (equalsAt > 0) {  
221.     String name = param.substring(0, equalsAt);  
222.     String value;  
223.     try {  
224.      value = URLDecoder.decode(param.substring(equalsAt + 1),  
225.        CHARSET);  
226.     } catch (UnsupportedEncodingException e) {  
227.      throw new RuntimeException("エンコード時の例外", e);  
228.     }  
229.     responseParameters.put(name, value);  
230.    }  
231.   }  
232.   return responseParameters;  
233.  }  
234. }  
235.   
236. </string,></string,></string,></string,></string,></string,></string,>  

/**
 * Copyright 2008 by EverNote Corporation.  All rights reserved.
 */

package jp.co.ziro.evernote.controller;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.TreeMap;
import java.util.logging.Logger;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.binary.Base64;
import org.slim3.util.ApplicationMessage;

/**
 * This is a very simple implementation of an OAuth consumer request which can
 * be used to ask an OAuth service provider for either a Request Token or an
 * Access Token. It only handles PLAINTEXT authentication, and it only goes over
 * a GET transport. As a result, it should only be used over SSL.
 * 
 * @author Dave Engberg
 */
public class EvernoteRequest {

    @SuppressWarnings("unused")
    private static Logger logger = Logger.getLogger(EvernoteRequest.class.getName());
 private static final String consumerKey = ApplicationMessage
   .get("evernote.api.key");
 private static final String consumerSecret = ApplicationMessage
   .get("evernote.api.secret");
 private static final String urlBase = ApplicationMessage
   .get("evernote.api.baseUrl");
 private static final String requestUrl = urlBase
   + ApplicationMessage.get("evernote.api.requestTokenUrl");
 /**
  * ベースのURL
  * @return
  */
 public static String getBaseUrl() {
  return urlBase;
 }

 /**
  * Random number generator for creating OAuth nonces
  */
 private static final Random random = new Random();

 /**
  * A mapping containing all of the OAuth parameters that will be passed in
  * the reply.
  */
 private Map parameters = new TreeMap();

 /**
  * Constructs a request object that can be used to make token requests from
  * an OAuth provider.
  */
 public EvernoteRequest() {
  setParameter("oauth_consumer_key", consumerKey);
  //暗号化を行う
  setParameter("oauth_signature_method", "HMAC-SHA1");
  setParameter("oauth_timestamp", getTimestamp());
  setParameter("oauth_nonce", Long.toHexString(random.nextLong()));
  setParameter("oauth_version", "1.0");
 }
 /**
  * タイムスタンプを作成
  * @return
  */
 private String getTimestamp() {
  return Long.toString(System.currentTimeMillis() / 1000);
 }

 /**
  * Sets one of the query string parameters for the request that will be made
  * to the OAuth provider. The value will be URL encoded before adding to the
  * URL.
  * 
  * @param name
  *            the name of the parameter to be set
  * @param value
  *            the string value, unencoded
  */
 public void setParameter(String name, String value) {
  parameters.put(name, value);
 }

 /**
  * Encodes this request as a single URL that can be opened.
  */
 private String encode() {
  return requestUrl + "?" + join();
 }

 /**
  * HTTP引数の連結
  * @return
  */
 private String join() {
  StringBuilder sb = new StringBuilder();
  boolean firstParam = true;
  for (Map.Entry parameter : parameters.entrySet()) {
   if (firstParam) {
    firstParam = false;
   } else {
    sb.append('&');
   }
   sb.append(parameter.getKey());
   sb.append('=');
   try {
    sb.append(URLEncoder.encode(parameter.getValue(), CHARSET));
   } catch (UnsupportedEncodingException e) {
    throw new RuntimeException("エンコード時の例外", e);
   }
  }
  return sb.toString();
 }

 /**
  * 文字コード
  */
 private static final String CHARSET = "UTF-8";
 /**
  * キー作成用のGETメソッド名
  */
 private static final String REQUEST_METHOD = "GET";

 /**
  * Sends the request to the OAuth Provider, and returns the set of reply
  * parameters, mapped from name to decoded value.
  * 
  * @throws IOException
  *             if a problem occurs making the request or getting the reply.
  */
 public Map sendRequest(String tokenSecret) throws IOException {
  // 署名対象のテキストを作成
  String secret = consumerSecret + "&";
  if (tokenSecret != null) {
   secret += tokenSecret;
  }

  String hmac = "HmacSHA1";
  
  String encodeUrl  = URLEncoder.encode(requestUrl,CHARSET);
  String encodeJoin = URLEncoder.encode(join(),CHARSET);

  String signatureBaseString = REQUEST_METHOD + "&" + encodeUrl + "&" + encodeJoin;
  logger.info(signatureBaseString);

        byte[] secretyKeyBytes = secret.getBytes(CHARSET);
     SecretKeySpec secretKeySpec =  new SecretKeySpec(secretyKeyBytes,hmac);
     Mac mac;
  try {
   mac = Mac.getInstance(hmac);
   mac.init(secretKeySpec);
  } catch (NoSuchAlgorithmException e1) {
   throw new RuntimeException("暗号化インスタンス取得失敗",e1);
  } catch (InvalidKeyException e1) {
   throw new RuntimeException("暗号化インスタンス取得失敗",e1);
  }
     
        String signature = null;
        byte[] data;
        byte[] rawHmac;
        try {
            data = signatureBaseString.getBytes(CHARSET);
            rawHmac = mac.doFinal(data);
            Base64 encoder = new Base64();
            signature = new String(encoder.encode(rawHmac));
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(CHARSET + " is unsupported!", e);
        }
  setParameter("oauth_signature", signature);

  HttpURLConnection connection = (HttpURLConnection) (new URL(encode())).openConnection();
  int responseCode = connection.getResponseCode();
  // リクエストが正常じゃない場合
  if (responseCode != HttpURLConnection.HTTP_OK) {
   throw new IOException("Server returned error code: " + responseCode
     + " " + connection.getResponseMessage());
  }
  return createResponseMap(connection);
 }

 /**
  * レスポンスの値を取得
  * 
  * @param connection
  * @return
  */
 private Map createResponseMap(HttpURLConnection connection) {

  BufferedReader bufferedReader;
  String result;
  try {
   bufferedReader = new BufferedReader(new InputStreamReader(
     connection.getInputStream()));
   result = bufferedReader.readLine();
  } catch (IOException e) {
   throw new RuntimeException("読み込み時の例外", e);
  }

  Map responseParameters = new HashMap();
  for (String param : result.split("&")) {
   int equalsAt = param.indexOf('=');
   if (equalsAt > 0) {
    String name = param.substring(0, equalsAt);
    String value;
    try {
     value = URLDecoder.decode(param.substring(equalsAt + 1),
       CHARSET);
    } catch (UnsupportedEncodingException e) {
     throw new RuntimeException("エンコード時の例外", e);
    }
    responseParameters.put(name, value);
   }
  }
  return responseParameters;
 }
}

・・・本当に汚い、、、
で、これを利用してindex時に

view plainprint?

1.         EvernoteRequest oauthRequestor = new EvernoteRequest();  
2.         String thisUrl = request.getRequestURL().toString();  
3.         String cbUrl = thisUrl.substring(0, thisUrl.lastIndexOf('/') + 1);  
4.         cbUrl = cbUrl + "callback";  
5.   
6.         oauthRequestor.setParameter("oauth_callback", cbUrl);  
7.         Map<string, string=""> reply = oauthRequestor.sendRequest(null);  
8.           
9.         String requestToken = reply.get("oauth_token");  
10.         String tokenSecret = reply.get("oauth_token_secret");  
11.         String authorizationUrl = authorizationUrlBase + "?oauth_token=" + requestToken;  
12.   
13.         sessionScope("tokenSecret",tokenSecret);  
14. </string,>  

        EvernoteRequest oauthRequestor = new EvernoteRequest();
        String thisUrl = request.getRequestURL().toString();
        String cbUrl = thisUrl.substring(0, thisUrl.lastIndexOf('/') + 1);
        cbUrl = cbUrl + "callback";

        oauthRequestor.setParameter("oauth_callback", cbUrl);
        Map reply = oauthRequestor.sendRequest(null);
        
        String requestToken = reply.get("oauth_token");
        String tokenSecret = reply.get("oauth_token_secret");
        String authorizationUrl = authorizationUrlBase + "?oauth_token=" + requestToken;

        sessionScope("tokenSecret",tokenSecret);

という風にします。
すべての引数を指定した後にoauth_signatureを生成するので
sendRequest()にtokenSecretを持ってきています。(コールバック時に利用)

リクエストトークンとともにtokenSecretは取得できます。
アクセストークンを取得する際に使用するtokenSecretをセッションに残しています。
で以下がコールバックの処理。

view plainprint?

1.         EvernoteRequest oauthRequestor = new EvernoteRequest();  
2.   
3.         String requestToken = requestScope("oauth_token");  
4.         String verifier     = requestScope("oauth_verifier");  
5.         String tokenSecret  = sessionScope("tokenSecret");  
6.   
7.         oauthRequestor.setParameter( "oauth_token", requestToken);  
8.         oauthRequestor.setParameter( "oauth_verifier", verifier);  
9.   
10.         //取得する  
11.         Map<string, string=""> reply = oauthRequestor.sendRequest(tokenSecret);  
12. </string,>  

        EvernoteRequest oauthRequestor = new EvernoteRequest();

        String requestToken = requestScope("oauth_token");
        String verifier     = requestScope("oauth_verifier");
        String tokenSecret  = sessionScope("tokenSecret");

        oauthRequestor.setParameter( "oauth_token", requestToken);
        oauthRequestor.setParameter( "oauth_verifier", verifier);

        //取得する
        Map reply = oauthRequestor.sendRequest(tokenSecret);

こちらはセッションからtokenSecretを取得して指定しているだけですね。

んーAuthrorization Headerでアクセスしたいですよねー。
アクセスもPOSTでもないですし。。。本物はそうしてみようっ。と。

次回、OAuthを読んでいくか、APIアクセスをもう少し行ってみるか悩んでます。
それを記述するのはOAuthの仕様なだけなのでそっち読めば良いかなぁ、、、と。