padding-oracle-attacker

Outil CLI et bibliothèque pour exécuter facilement des attaques par oracle de padding, avec prise en charge des requêtes réseau concurrentes et une interface utilisateur élégante.

Installation

Assurez-vous que Node.js est installé, puis exécutez

$ npm install --global padding-oracle-attacker

ou

$ yarn global add padding-oracle-attacker

Utilisation en CLI

Utilisation
  $ padding-oracle-attacker decrypt <url> hex:<ciphertext_hex> <block_size> <error> [options]
  $ padding-oracle-attacker decrypt <url> b64:<ciphertext_b64> <block_size> <error> [options]

  $ padding-oracle-attacker encrypt <url> <plaintext>          <block_size> <error> [options]
  $ padding-oracle-attacker encrypt <url> hex:<plaintext_hex>  <block_size> <error> [options]

  $ padding-oracle-attacker analyze <url> [<block_size>] [options]

Commandes
  decrypt                  Trouve le texte clair (foobar) pour le texte chiffré donné (hex:0123abcd)
  encrypt                  Trouve le texte chiffré (hex:abcd1234) pour le texte clair donné (foo=bar)
  analyze                  Aide à déterminer si l'URL est vulnérable ou non, et
                           comment la réponse diffère lorsqu'une erreur de déchiffrement se produit
                           (pour l'argument <error>)

Arguments
  <url>                    URL à attaquer. La charge utile sera insérée à la fin par défaut. Pour spécifier
                           un point d'injection personnalisé, incluez {POPAYLOAD} dans un en-tête (-H),
                           le corps de la requête (-d) ou l'URL
  <block_size>             Taille de bloc utilisée par l'algorithme de chiffrement sur le serveur
  <error>                  La chaîne présente dans la réponse lorsque le déchiffrement échoue sur le serveur.
                           Spécifiez une chaîne présente dans le corps de la réponse HTTP (comme PaddingException)
                           ou le code de statut de la réponse HTTP (comme 400)

Options
  -c, --concurrency        Requêtes à envoyer de manière concurrente                [défaut: 128]
      --disable-cache      Désactiver le cache réseau. Sauvegardé dans                   [défaut: false]
                           poattack-cache.json.gz.txt par défaut
  -X, --method             Méthode HTTP à utiliser pour la requête               [défaut: GET]
  -H, --header             En-têtes à envoyer avec la requête.
                             -H 'Cookie: cookie1' -H 'User-Agent: Googlebot/2.1'
  -d, --data               Corps de la requête
                             Chaîne JSON: {"id": 101, "foo": "bar"}
                             Encodé URL: id=101&foo=bar
                           Assurez-vous de spécifier l'en-tête Content-Type.

  -e, --payload-encoding   Encodage de la charge utile du texte chiffré pour {POPAYLOAD}           [défaut: hex]
                             base64          FooBar+/=
                             base64-urlsafe  FooBar-_
                             hex             deadbeef
                             hex-uppercase   DEADBEEF
                             base64(xyz)     Base64 personnalisé ('xyz' représente les caractères pour '+/=')

  --dont-urlencode-payload Ne pas encoder URL {POPAYLOAD}                          [défaut: false]

  --start-from-1st-block   Commencer le traitement par le premier bloc au lieu         [défaut: false]
                           du dernier (fonctionne uniquement avec le mode decrypt)

Exemples
  $ poattack decrypt http://localhost:2020/decrypt?ciphertext=
      hex:e3e70d8599206647dbc96952aaa209d75b4e3c494842aa1aa8931f51505df2a8a184e99501914312e2c50320835404e9
      16 400
  $ poattack encrypt http://localhost:2020/decrypt?ciphertext= "foo bar 🦄" 16 400
  $ poattack encrypt http://localhost:2020/decrypt?ciphertext= hex:666f6f2062617220f09fa684 16 400
  $ poattack analyze http://localhost:2020/decrypt?ciphertext=

Alias
  poattack
  padding-oracle-attack

API de la bibliothèque

const { decrypt, encrypt } = require('padding-oracle-attacker')
// ou
import { decrypt, encrypt } from 'padding-oracle-attacker'

const { blockCount, totalSize, foundBytes, interBytes } = await decrypt(options)

const { blockCount, totalSize, foundBytes, interBytes, finalRequest } = await encrypt(options)

decrypt(options: Object): Promise

encrypt(options: Object): Promise

Options obligatoires

url: string

URL à attaquer. La charge utile sera ajoutée à la fin par défaut. Pour spécifier un point d'injection personnalisé, incluez {POPAYLOAD} dans l'URL, un en-tête (requestOptions.headers) ou le corps de la requête (requestOptions.data)

blockSize: number

Taille de bloc utilisée par l'algorithme de chiffrement sur le serveur.

isDecryptionSuccess: ({ statusCode, headers, body }) => boolean

Fonction qui renvoie true si la réponse du serveur indique que le déchiffrement a réussi.

ciphertext: Buffer (decrypt uniquement)

Texte chiffré à déchiffrer.

plaintext: Buffer (encrypt uniquement)

Texte clair à chiffrer. Le remplissage (padding) sera ajouté automatiquement. Exemple : Buffer.from('foo bar', 'utf8')

---

Options facultatives

concurrency: number = 128

Requêtes réseau à envoyer de manière concurrente.

isCacheEnabled: boolean = true

Les réponses sont mises en cache par défaut et sauvegardées dans poattack-cache.json.gz.txt. Mettre à false pour désactiver le cache.

requestOptions: { method, headers, data }

requestOptions.method: string

Méthode HTTP à utiliser pour la requête. GET par défaut. POST, PUT, DELETE sont quelques options valides.

requestOptions.headers: { string: string }

En-têtes à envoyer avec la requête. Exemple : { 'Content-Type': 'application/x-www-form-urlencoded' }

requestOptions.body: string

Corps de la requête. Peut être une chaîne JSON, des paramètres encodés URL, etc. L'en-tête Content-Type doit être défini manuellement.

logMode: 'full'|'minimal'|'none' = 'full'

full : Tout journaliser dans la console (par défaut)
minimal : Journaliser seulement après le début et après la fin
none : Ne rien journaliser dans la console

transformPayload: (ciphertext: Buffer) => string

Fonction pour convertir le ciphertext en une chaîne lors de la requête. Par défaut, ciphertext est encodé en hexadécimal et inséré au point d'injection (fin de l'URL sauf si {POPAYLOAD} est présent).

---

Options facultatives (decrypt uniquement)

alreadyFound: Buffer

Octets de texte clair déjà connus/trouvés qui peuvent être ignorés (depuis la fin). Si vous fournissez un Buffer de dix octets, les dix derniers octets seront ignorés.

initFirstPayloadBlockWithOrigBytes: boolean = false

Initialiser le premier bloc de charge utile avec les octets originaux du ciphertext au lieu de zéros.
Exemple : abcdef12345678ff 1111111111111111 au lieu de 00000000000000ff 1111111111111111

startFromFirstBlock: boolean = false

Commencer le traitement par le premier bloc au lieu du dernier.

makeInitialRequest: boolean = true

Effectuer une requête initiale avec le ciphertext original fourni et journaliser la réponse du serveur dans la console pour permettre à l'utilisateur de vérifier que les requêtes sont envoyées correctement.

---

Options facultatives (encrypt uniquement)