OAuth 1.0-Autorisierungsprobleme mit X API v2 in Scala über STTP

Auflösen der OAuth 1.0-Autorisierung mit Scala und STTP für die Twitter-API

Dieses Skript zeigt, wie OAuth 1.0-Anfragen in Scala mit HMAC-SHA1 signiert werden. Es gewährleistet Modularität und Fehlerbehandlung, was zu wiederverwendbarem, wartbarem Code führt.

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)
  }
}

Alternativer Ansatz: OAuth 1.0 mit benutzerdefinierter Nonce- und Zeitstempelbehandlung

Diese Methode rationalisiert den Signaturprozess, indem sie sich auf die Generierung maßgeschneiderter Nonces und Zeitstempel mit minimalen Abhängigkeiten konzentriert.

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)
  }
}

Häufig gestellte Fragen zu OAuth 1.0 und der Twitter-API-Authentifizierung

1. Wie unterscheidet sich OAuth 1.0 von OAuth 2.0?
2. OAuth 1.0 verwendet aus Sicherheitsgründen Signaturen und HMAC-SHA1-Verschlüsselung, während OAuth 2.0 eine tokenbasierte Autorisierung verwendet, was den Prozess vereinfacht, aber sichere HTTPS-Verbindungen erfordert.
3. Was ist der Zweck einer Nonce in OAuth 1.0?
4. Um Replay-Angriffe zu verhindern, generiert jede Anfrage eine eindeutige Zeichenfolge, die als Nonce bezeichnet wird. Es stellt sicher, dass jede Anfrage nur einmal ausgeführt wird. Mit Scala können Sie eine Nonce erstellen Random.alphanumeric.take().
5. Warum ist eine URL-Kodierung in OAuth-Anfragen erforderlich?
6. Die URL-Kodierung ist von entscheidender Bedeutung, da bestimmte Zeichen wie kaufmännische Und-Zeichen (&) oder Leerzeichen kodiert werden müssen, um Fehlinterpretationen zu vermeiden. Verwenden URLEncoder.encode() um diese Zeichen sicher zu kodieren.
7. Wie erstelle ich eine OAuth-Signatur?
8. Um eine OAuth-Signatur zu erstellen, erstellen Sie zunächst eine Basiszeichenfolge aus den Anforderungsdaten und signieren Sie diese dann mit der HMAC-SHA1-Technik. Verwenden Mac.getInstance("HmacSHA1") um den Hashing-Prozess zu starten.
9. Was kann einen 401 Unauthorized-Fehler in OAuth verursachen?
10. Ein 401-Fehler kann durch eine Vielzahl von Fehlern verursacht werden, darunter eine ungültige Signatur, nicht übereinstimmende Verbraucherschlüssel oder eine ungeeignete Parameterkodierung. Stellen Sie immer sicher, dass die Signatur mit den Anforderungsdaten übereinstimmt und dass die Verschlüsselung korrekt ist.

Abschließende Gedanken zur Lösung von Twitter-OAuth-Problemen

Um eine OAuth 1.0-Anfrage für die Twitter-API ordnungsgemäß zu autorisieren, müssen Entwickler Signaturen und Header sorgfältig verwalten. Viele Probleme werden durch Kodierungsprobleme oder die Verwendung des falschen Basiszeichenfolgenformats verursacht. Fehler wie „401 Unauthorized“ können verhindert werden, indem diese Probleme entsprechend behoben werden.

Darüber hinaus steigert die erneute Überprüfung der Nonce-Erstellung, der Zeitstempelgenauigkeit und der Header-Formatierung den Autorisierungserfolg erheblich. Die Optimierung der sha1sign-Methode, die Sicherstellung einer genauen Signaturberechnung und die Einhaltung der OAuth-Anforderungen sind entscheidende Schritte bei der Entwicklung einer funktionalen und automatisierten X-Publishing-Anwendung.