Masalah Otorisasi OAuth 1.0 dengan X API v2 di Scala melalui STTP

Menyelesaikan Otorisasi OAuth 1.0 dengan Scala dan STTP untuk Twitter API

Skrip ini menunjukkan cara menandatangani permintaan OAuth 1.0 di Scala menggunakan HMAC-SHA1. Ini memastikan modularitas dan penanganan kesalahan, sehingga menghasilkan kode yang dapat digunakan kembali dan dipelihara.

import java.net.URLEncoder
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import org.joda.time.DateTime
import sttp.client4._
import sttp.model.Header
import scala.util.Random
object Auth {
  def urlEncode(text: String): String =
    URLEncoder.encode(text, java.nio.charset.Charset.defaultCharset())
  def generateNonce: String = Random.alphanumeric.take(15).mkString
  def sha1sign(text: String, key: String): String = {
    val mac = Mac.getInstance("HmacSHA1")
    val signingKey = new SecretKeySpec(key.getBytes, "HmacSHA1")
    mac.init(signingKey)
    val signature = mac.doFinal(text.getBytes("UTF-8"))
    java.util.Base64.getEncoder.encodeToString(signature)
  }
  def createHeader(authData: Map[String, String]): Header = {
    val signatureBaseString = "POST&" + urlEncode("https://api.twitter.com/2/tweets") + "&" +
      urlEncode(authData.toSeq.sorted.map(x => s"${x._1}=${x._2}").mkString("&"))
    val signature = sha1sign(signatureBaseString, "consumerSecret&tokenSecret")
    val authHeader = "OAuth " + authData.map { case (k, v) => s"""$k="${urlEncode(v)}"""" }.mkString(", ") +
      s""", oauth_signature="${urlEncode(signature)}""""
    Header("Authorization", authHeader)
  }
}
object TwitterApi {
  val postEndpoint = "https://api.twitter.com/2/tweets"
  def createPost(text: String): Response = {
    val authData = Map(
      "oauth_consumer_key" -> "yourConsumerKey",
      "oauth_nonce" -> Auth.generateNonce,
      "oauth_signature_method" -> "HMAC-SHA1",
      "oauth_timestamp" -> DateTime.now().getMillis.toString,
      "oauth_token" -> "yourToken",
      "oauth_version" -> "1.0"
    )
    val header = Auth.createHeader(authData)
    basicRequest
      .header(header)
      .contentType("application/json")
      .body(s"""{"text":"$text"}""")
      .post(uri"$postEndpoint")
      .send(backend)
  }
}

Pendekatan Alternatif: OAuth 1.0 dengan Penanganan Nonce Khusus dan Stempel Waktu

Metode ini menyederhanakan proses tanda tangan dengan berfokus pada menghasilkan nonce dan stempel waktu yang dipesan lebih dahulu dengan ketergantungan minimal.

import java.net.URLEncoder
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import sttp.client4._
import sttp.model.Header
object OAuthHelper {
  def generateTimestamp: String = (System.currentTimeMillis / 1000).toString
  def generateNonce: String = java.util.UUID.randomUUID().toString.replace("-", "")
  def urlEncode(value: String): String = URLEncoder.encode(value, "UTF-8")
  def hmacSha1(baseString: String, key: String): String = {
    val mac = Mac.getInstance("HmacSHA1")
    val signingKey = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA1")
    mac.init(signingKey)
    val rawHmac = mac.doFinal(baseString.getBytes("UTF-8"))
    java.util.Base64.getEncoder.encodeToString(rawHmac)
  }
}
object TwitterClient {
  def createAuthorizationHeader(params: Map[String, String], signature: String): Header = {
    val headerParams = params.map { case (k, v) => s"""$k="${OAuthHelper.urlEncode(v)}"""" }.mkString(", ")
    Header("Authorization", s"""OAuth $headerParams, oauth_signature="$signature"""")
  }
  def postTweet(text: String): Response = {
    val params = Map(
      "oauth_consumer_key" -> "consumerKey",
      "oauth_nonce" -> OAuthHelper.generateNonce,
      "oauth_signature_method" -> "HMAC-SHA1",
      "oauth_timestamp" -> OAuthHelper.generateTimestamp,
      "oauth_token" -> "accessToken",
      "oauth_version" -> "1.0"
    )
    val baseString = "POST&" + OAuthHelper.urlEncode("https://api.twitter.com/2/tweets") + "&" +
      OAuthHelper.urlEncode(params.toSeq.sorted.map { case (k, v) => s"$k=$v" }.mkString("&"))
    val signature = OAuthHelper.hmacSha1(baseString, "consumerSecret&tokenSecret")
    val authHeader = createAuthorizationHeader(params, signature)
    basicRequest
      .header(authHeader)
      .contentType("application/json")
      .body(s"""{"text":"$text"}""")
      .post(uri"https://api.twitter.com/2/tweets")
      .send(backend)
  }
}

Pertanyaan Umum Tentang OAuth 1.0 dan Otentikasi API Twitter

1. Apa perbedaan OAuth 1.0 dengan OAuth 2.0?
2. OAuth 1.0 menggunakan tanda tangan dan enkripsi HMAC-SHA1 untuk keamanan, sedangkan OAuth 2.0 menggunakan otorisasi berbasis token, yang menyederhanakan proses tetapi memerlukan koneksi HTTPS yang aman.
3. Apa tujuan nonce di OAuth 1.0?
4. Untuk mencegah serangan replay, setiap permintaan menghasilkan string unik yang dikenal sebagai nonce. Ini memastikan bahwa setiap permintaan hanya dieksekusi satu kali. Scala memungkinkan Anda membuat nonce menggunakan Random.alphanumeric.take().
5. Mengapa pengkodean URL diperlukan dalam permintaan OAuth?
6. Pengkodean URL sangat penting karena karakter tertentu, seperti ampersand (&) atau spasi, harus dikodekan untuk menghindari salah tafsir. Menggunakan URLEncoder.encode() untuk mengkodekan karakter ini dengan aman.
7. Bagaimana cara menghasilkan tanda tangan OAuth?
8. Untuk membuat tanda tangan OAuth, pertama-tama buat string dasar dari data permintaan, lalu tanda tangani dengan teknik HMAC-SHA1. Menggunakan Mac.getInstance("HmacSHA1") untuk memulai proses hashing.
9. Apa yang dapat menyebabkan kesalahan 401 Tidak Sah di OAuth?
10. Kesalahan 401 dapat disebabkan oleh berbagai kesalahan, termasuk tanda tangan yang tidak valid, kunci konsumen yang tidak cocok, atau pengkodean parameter yang tidak tepat. Selalu pastikan bahwa tanda tangan cocok dengan data permintaan dan pengkodeannya akurat.

Pemikiran Terakhir tentang Memecahkan Masalah OAuth Twitter

Untuk mengotorisasi permintaan OAuth 1.0 untuk API Twitter dengan benar, pengembang harus mengelola tanda tangan dan header dengan cermat. Banyak masalah yang disebabkan oleh masalah pengkodean atau penggunaan format string dasar yang salah. Kesalahan seperti "401 Tidak Sah" dapat dicegah dengan mengatasi masalah ini dengan tepat.

Selain itu, memeriksa ulang pembuatan nonce, keakuratan stempel waktu, dan pemformatan header akan sangat meningkatkan keberhasilan otorisasi. Mengoptimalkan metode sha1sign, memastikan penghitungan tanda tangan yang akurat, dan mematuhi persyaratan OAuth merupakan tahapan penting dalam mengembangkan aplikasi penerbitan X yang fungsional dan otomatis.