Besoin d'aide ici avec un déchiffrement PGP symétrique dans le Golang, j'ai essayé d'exécuter un déchiffrement symétrique sur un hexadécimal chiffré généré sur OpenPGP.js, malheureusement, aucun succès à déchiffrer dans le Golang. C'est le cryptage en JS.

const openpgp = require('openpgp')

async function main() {
  let options = {
    message: openpgp.message.fromBinary(new Uint8Array([0x01, 0x01, 0x01])), // input as Message object
    passwords: ['secret stuff'],                                             // multiple passwords possible
    armor: false                                                             // don't ASCII armor (for Uint8Array output)
  }

  const cypher_text = await openpgp.encrypt(options)
  const encrypted = cypher_text.message.packets.write()

  console.log(Buffer.from(encrypted).toString('hex'))

  options = {
    message: await openpgp.message.read(encrypted), // parse encrypted bytes
    passwords: ['secret stuff'],              // decrypt with password
    format: 'binary'                          // output as Uint8Array
  }

  const decrypted = await openpgp.decrypt(options)

  console.log(decrypted.data)
}

main()

Console.log >>

c32e040903088c4db97456263252e0ef4f42627301e0ba3323b141a9ebd0476e5fe848d3c2b6021c8c06581ae2d19f7cd23b011b4b3a68758cb6fb12287db2a9ab6fdfad97670ae995e4deb7ca313d0aa705d264850adefb20353b263fc32ff8dc571f6dce8b722ddbdf40a907

Uint8Array [ 1, 1, 1 ]

Mon code est basé sur le GIST suivant https://gist.github.com/jyap808/8250124

package main

import (
    "bytes"
    "errors"
    "io/ioutil"
    "log"

    "golang.org/x/crypto/openpgp/armor"
    "golang.org/x/crypto/openpgp/packet"

    "golang.org/x/crypto/openpgp"
)

func main() {
    password := []byte("secret stuff")
    packetConfig := &packet.Config{
        DefaultCipher: packet.CipherAES256,
    }

    cypherHex := []byte("c32e040903088c4db97456263252e0ef4f42627301e0ba3323b141a9ebd0476e5fe848d3c2b6021c8c06581ae2d19f7cd23b011b4b3a68758cb6fb12287db2a9ab6fdfad97670ae995e4deb7ca313d0aa705d264850adefb20353b263fc32ff8dc571f6dce8b722ddbdf40a907")

    encbuf := bytes.NewBuffer(nil)
    w, err := armor.Encode(encbuf, openpgp.SignatureType, nil)
    if err != nil {
        log.Fatal(err)
    }

    w.Write(cypherHex)
    encbuf.Read(cypherHex)
    w.Close()

    log.Println(encbuf)

    decbuf := bytes.NewBuffer([]byte(encbuf.String()))
    armorBlock, err := armor.Decode(decbuf)
    if err != nil {
        log.Fatalf("Failed on decode %+v\n", err)
    }

    failed := false
    prompt := func(keys []openpgp.Key, symmetric bool) ([]byte, error) {
        if failed {
            return nil, errors.New("decryption failed")
        }
        return password, nil
    }

    md, err := openpgp.ReadMessage(armorBlock.Body, nil, prompt, packetConfig)
    if err != nil {
        log.Fatalf("Failed on read message %+v\n", err)
    }

    plaintext, err := ioutil.ReadAll(md.UnverifiedBody)
    if err != nil {
        log.Fatalf("Failed on read all body %+v\n", err)
    }

    log.Println(plaintext)
}

J'ai remarqué après avoir enregistré l'encbuf que la clé blindée est un peu incomplète

2020/01/24 22:51:54 jcwYWU5
OTVlNGRlYjdjYTMxM2QwYWE3MDVkMjY0ODUwYWRlZmIyMDM1M2IyNjNmYzMyZmY4
ZGM1NzFmNmRjZThiNzIyZGRiZGY0MGE5MDc=
=9ciH
-----END PGP SIGNATURE-----

Mise à jour : essayer de décrypter sans armure également, en cas d'échec avec EOF


import (
    "bytes"
    "io/ioutil"
    "log"

    "golang.org/x/crypto/openpgp"

    "golang.org/x/crypto/openpgp/packet"
)

func main() {
    password := []byte("secret stuff")
    packetConfig := &packet.Config{
        DefaultCipher: packet.CipherAES128,
    }

    cypherHex := []byte("c32e040903088c4db97456263252e0ef4f42627301e0ba3323b141a9ebd0476e5fe848d3c2b6021c8c06581ae2d19f7cd23b011b4b3a68758cb6fb12287db2a9ab6fdfad97670ae995e4deb7ca313d0aa705d264850adefb20353b263fc32ff8dc571f6dce8b722ddbdf40a907")

    encbuf := bytes.NewBuffer(nil)
    encbuf.Read(cypherHex)

    prompt := func(keys []openpgp.Key, symmetric bool) ([]byte, error) {
        return password, nil
    }

    md, err := openpgp.ReadMessage(encbuf, nil, prompt, packetConfig)
    if err != nil {
        log.Fatalf("Failed on read message %+v\n", err)
    }

    plaintext, err := ioutil.ReadAll(md.UnverifiedBody)
    if err != nil {
        log.Fatalf("Failed on read all body %+v\n", err)
    }

    log.Println(plaintext)
}
0
Eduardo Pereira 25 janv. 2020 à 00:11

1 réponse

Meilleure réponse

Premièrement, vous ne décodez pas le texte chiffré en hexadécimal. Utilisez le package encoding/hex pour décoder les données :

ct, err := hex.DecodeString(`c32e040903088c4db97456263252e0ef4f42627301e0ba3323b141a9ebd0476e5fe848d3c2b6021c8c06581ae2d19f7cd23b011b4b3a68758cb6fb12287db2a9ab6fdfad97670ae995e4deb7ca313d0aa705d264850adefb20353b263fc32ff8dc571f6dce8b722ddbdf40a907`)
if err != nil {
    log.Fatal(err)
}

Le problème suivant est que vous créez incorrectement le bytes.Buffer. Vous ne mettez aucune donnée dans le tampon, puis appelez la méthode Read qui ne fait rien (et si vous l'avez initialisé avec des données, Read "lirait" toutes les données avant de les déchiffrer de toute façon ). Le tampon peut être initialisé avec les données ou rempli à l'aide de la méthode Write -- dans ce cas, vous n'avez besoin que d'un io.Reader et pouvez utiliser bytes.NewReader.

r := bytes.NewReader(ct)

Enfin, vous disposez maintenant de 3 0x01 octets, que vous pouvez voir plus clairement en utilisant un meilleur formatage :

d, err := ioutil.ReadAll(md.UnverifiedBody)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("%#v\n", d)

https://play.golang.org/p/Y3VqADQvEIH

1
JimB 27 janv. 2020 à 18:15