ECDSA подписи между Node.js и WebCrypto кажутся несовместимыми?

Question

Я использую следующий пример для подписи + проверки в Node.js: https://github.com/nodejs/node-v0.x-archive/issues/6904. Проверка успешно выполняется в Node.js, но не выполняется в WebCrypto. Аналогично, сообщение, подписанное с использованием WebCrypto, не может быть проверено в Node.js.

Вот код, который я использовал для проверки подписи, созданной из скрипта Node.js с помощью WebCrypto - https://jsfiddle.net/aj49e8sj/. Протестировано как в Chrome 54.0.2840.27, так и в Firefox 48.0.2

// From https://github.com/nodejs/node-v0.x-archive/issues/6904
var keys = {
  priv: '-----BEGIN EC PRIVATE KEY-----\n' +
        'MHcCAQEEIF+jnWY1D5kbVYDNvxxo/Y+ku2uJPDwS0r/VuPZQrjjVoAoGCCqGSM49\n' +
        'AwEHoUQDQgAEurOxfSxmqIRYzJVagdZfMMSjRNNhB8i3mXyIMq704m2m52FdfKZ2\n' +
        'pQhByd5eyj3lgZ7m7jbchtdgyOF8Io/1ng==\n' +
        '-----END EC PRIVATE KEY-----\n',
  pub: '-----BEGIN PUBLIC KEY-----\n' +
       'MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEurOxfSxmqIRYzJVagdZfMMSjRNNh\n' +
       'B8i3mXyIMq704m2m52FdfKZ2pQhByd5eyj3lgZ7m7jbchtdgyOF8Io/1ng==\n' +
       '-----END PUBLIC KEY-----\n'
};
var message = (new TextEncoder('UTF-8')).encode('hello');

// Algorithm used in Node.js script is ecdsa-with-SHA1, key generated with prime256v1
var algorithm = {
    name: 'ECDSA',
    namedCurve: 'P-256',
    hash: {
        name: 'SHA-1'
    }
};

// Signature from obtained via above Node.js script
var sig64 = 'MEUCIQDkAtiomagyHFi7dNfxMrzx/U0Gk/ZhmwCqaL3TimvlswIgPgeDqgZNqfR5/FZZASYsczUAhGSXjuycLhWnvk20qKc=';

// Decode base64 string into ArrayBuffer
var b64Decode = (str) => Uint8Array.from(atob(str), x => x.charCodeAt(0));

// Get base64 string from public key
const key64 = keys.pub.split('\n')
    .filter(x => x.length > 0 && !x.startsWith('-----'))
    .join('');

// Convert to buffers
var sig = b64Decode(sig64);
var keySpki = b64Decode(key64);

// Import and verify
// Want 'Verification result: true' but will get 'false'
var importKey = crypto.subtle.importKey('spki', keySpki, algorithm, true, ['verify'])
    .then(key => crypto.subtle.verify(algorithm, key, sig, message))
    .then(result => console.log('Verification result: ' + result));

Связанный вопрос с похожей проблемой с использованием SHA-256 вместо SHA-1: Генерация подписи ECDSA с помощью Node.js / crypto

Вещи, которые я проверил:

• Я расшифровал ключи Node.js и убедился, что они имеют тот же OID, что и ключи, сгенерированные через WebCrypto. Это говорит мне, что я использую правильные кривые.
• SHA-1 явно идентифицируется как хеш для использования в обоих местах.
• ECDSA явно идентифицируется как в Node.js, так и в WebCrypto.

Как я могу успешно проверить подпись, полученную от Node.js и наоборот - проверить подпись в Node.js, созданную из WebCrypto? Или реализации стандарта немного отличаются друг от друга таким образом, что делает их несовместимыми?

Редактировать:

• Подпись WebCrypto (64 байта): uTaUWTfF+AjN3aPj0b5Z2d1HybUEpV/phv/P9RtfKaGXtcYnbgfO43IRg46rznG3/WnWwJ2sV6mPOEnEPR0vWw==
• Подпись Node.js (71 байт): MEUCIQDkAtiomagyHFi7dNfxMrzx/U0Gk/ZhmwCqaL3TimvlswIgPgeDqgZNqfR5/FZZASYsczUAhGSXjuycLhWnvk20qKc=

Проверенная подпись Node.js зашифрована с помощью DER, а подпись WebCrypto - нет.

Answer 1

Не использовав ни одну из этих библиотек, я не могу сказать наверняка, но одна возможность состоит в том, что они не используют один и тот же тип кодировки для подписи. Для DSA/ECDSA существует два основных формата: IEEE P1363 (используется Windows) и DER (используется OpenSSL).

Формат "Windows" должен иметь заданный размер (определяется Q для DSA и P для ECDSA (Windows не поддерживает Char-2, но если бы это было так, то, вероятно, было бы M для Char-2 ECDSA)). Тогда оба r а также s дополнены левой 0 пока они не встретят эту длину.

В слишком мал, чтобы быть легальным примером r = 0x305 а также s = 0x810522 с sizeof(Q), составляющим 3 байта:

// r
000305
// s
810522

Для формата "OpenSSL" он кодируется по правилам DER как SEQUENCE(INTEGER(r), INTEGER(s)), который выглядит следующим образом

// SEQUENCE
30
  // (length of payload)
  0A
  // INTEGER(r)
  02
    // (length of payload)
    02
    // note the leading 0x00 is omitted
    0305
  // INTEGER(s)
  02
    // (length of payload)
    04
    // Since INTEGER is a signed type, but this represented a positive number,
    // a 0x00 has to be inserted to keep the sign bit clear.
    00810522

или, компактно:

• Окна: 000305810522
• OpenSSL: 300A02020305020400810522

Формат "Windows" всегда ровный, всегда одинаковой длины. Формат "OpenSSL" обычно на 6 байтов больше, но может получить или потерять байт в середине; так что иногда даже, иногда странно.

Base64-декодирование вашего sig64 значение показывает, что используется кодировка DER. Создать пару подписей с помощью WebCrypto; если таковые не начинаются с 0x30 тогда у вас есть проблема IEEE/DER.

Answer 2

Через много часов, наконец, найти решение с нулевой зависимости!

В браузере:

      // Tip: Copy & Paste in the console for test.

      // Text to sign:
      var source = 'test';

      // Auxs
      function length(hex) {
        return ('00' + (hex.length / 2).toString(16)).slice(-2).toString();
      }

      function pubKeyToPEM(key) {
        var pem = '-----BEGIN PUBLIC KEY-----\n',
            keydata = '',
            bytes = new Uint8Array( key );

        for (var i = 0; i < bytes.byteLength; i++) {
          keydata += String.fromCharCode( bytes[ i ] );
        }

        keydata = window.btoa(keydata);

        while(keydata.length > 0) {
          pem += keydata.substring(0, 64) + '\n';
          keydata = keydata.substring(64);
        }

        pem = pem + "-----END PUBLIC KEY-----";

        return pem;
      }

      // Generate new keypair.
      window.crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-384" }, true, ["sign", "verify"])
            .then(function(keypair) {

              // Encode as UTF-8
              var enc = new TextEncoder('UTF-8'),
                  digest = enc.encode(source);
              
              // Sign with subtle
              window.crypto.subtle.sign({ name: "ECDSA", hash: {name: "SHA-1"} }, keypair.privateKey, digest)
                    .then(function(signature) {
                        signature = new Uint8Array(signature);

                        // Extract r & s and format it in ASN1 format.
                        var signHex = Array.prototype.map.call(signature, function(x) { return ('00' + x.toString(16)).slice(-2); }).join(''),
                            r = signHex.substring(0, 96),
                            s = signHex.substring(96),
                            rPre = true,
                            sPre = true;

                        while(r.indexOf('00') === 0) {
                          r = r.substring(2);
                          rPre = false;
                        }

                        if (rPre && parseInt(r.substring(0, 2), 16) > 127) {
                          r = '00' + r;
                        }

                        while(s.indexOf('00') === 0) {
                          s = s.substring(2);
                          sPre = false;
                        }

                        if(sPre && parseInt(s.substring(0, 2), 16) > 127) {
                          s = '00' + s;
                        }

                        var payload = '02' + length(r) + r +
                                      '02' + length(s) + s,
                            der = '30' + length(payload) + payload;
                        
                        // Export public key un PEM format (needed by node)
                        window.crypto.subtle.exportKey('spki', keypair.publicKey)
                                                   .then(function(key) {
                                                      var pubKey = pubKeyToPEM(key);
                                                      
                                                      console.log('This is pubKey -> ', pubKey);
                                                      console.log('This is signature -> ', der);                                                      
                                                   });
                                         
                        
                        // For test, we verify the signature, nothing, anecdotal.
                        window.crypto.subtle.verify({ name: "ECDSA", hash: {name: "SHA-1"} }, keypair.publicKey, signature, digest)
                              .then(console.log);
                    });
                    
            });

В узле:

const crypto = require('crypto');

// ----------------------------------------------------------------------------

// Paste from browser!

var puKeyPem = '-----BEGIN PUBLIC KEY-----\n' +
               'MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEmDubwJuORpMMoMnvv59W8tU8PxPChh75\n' +
               'vjlfVB2+tPY5KDy1I0ohz2US+2K1T/ROcDCSRAjyONRzzwVBm9S6bqbk3KuaT2KG\n' +
               'ikoe0KLfTeQtdEUyq8J0aEOKRXoCJLZq\n' +
               '-----END PUBLIC KEY-----';
               
var hexSign = '306402305df22aa5f4e7200b7c264c891cd3a8c5b4622c25872020832d5bb3d251773592020249a46a8349754dc58c47c4cbb7c9023053b929a98f5c8cccf2c1a4746d82fc751e044b1f76dffdf9ef73f73bee1499c5e20aadddda41e3373760b8b0f3c1bbb2';

// ----------------------------------------------------------------------------

var verifier = crypto.createVerify('sha1'),
    digest   = 'test';
    
verifier.update(digest);
verifier.end();

console.log(verifier.verify(puKeyPem, hexSign, 'hex'));

// ----------------------------------------------------------------------------

Answer 3

Теперь вы можете создавать совместимые (nodejs vs webcrypto) ключи и подписи, не изменяя их. Следующий пример относится к RSA, но ECDSA должен быть очень похожим - суть в типах / форматах / кодировках.

Сгенерируйте пару ключей (nodejs):

const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048,
  publicKeyEncoding: {
    type: 'spki',
    format: 'der'
  },
  privateKeyEncoding: {
    type: 'pkcs8',
    format: 'der'
  }
});
    
console.log('PRIVATE', Buffer.from(privateKey).toString('base64'));
console.log('PUBLIC', Buffer.from(publicKey).toString('base64'));

Подписать сообщение (nodejs):

const signature = crypto.sign(
  'sha256',
  Buffer.from('The quick brown fox jumps over the lazy dog', 'utf8'),
  {
    key: crypto.createPrivateKey({
      key: Buffer.from('...base64 encoded private key', 'base64'),
      format: 'der',
      type: 'pkcs8'
    }),
    padding: crypto.constants.RSA_PKCS1_PADDING,
    dsaEncoding: 'ieee-p1363'
  }
);

console.log('SIGNATURE', signature.toString('base64'));

Проверить сообщение (webcrypto) - вам нужно изменить функции буфера в vanilla js:

  (async () => console.log(await crypto.subtle.verify(
    { name: 'RSASSA-PKCS1-v1_5' },
    await crypto.subtle.importKey(
      'spki',
      Buffer.from('...base64 encoded public key', 'base64'),
      { name: 'RSASSA-PKCS1-v1_5', hash: {name: 'SHA-256'} },
      false,
      [ 'verify' ]
    ),
    Buffer.from('...base64 encoded signature', 'base64'),
    Buffer.from('The quick brown fox jumps over the lazy dog', 'utf8')
  )))();