loadPrivateKeyFromOpenSSHPem static method

Uint8List loadPrivateKeyFromOpenSSHPem(String pemFileContent, { String? password, })

Loads a private key from a pemFileContent that has been encoded with the open ssh file format:

https://github.com/openssh/openssh-portable/blob/master/PROTOCOL.key

"openssh-key-v1"0x00 # NULL-terminated "Auth Magic" string 32-bit length, "none" # ciphername length and string 32-bit length, "none" # kdfname length and string 32-bit length, nil # kdf (0 length, no kdf) 32-bit 0x01 # number of keys, hard-coded to 1 (no length) 32-bit length, sshpub # public key in ssh format 32-bit length, keytype 32-bit length, pub0 32-bit length, pub1 32-bit length for rnd+prv+comment+pad 64-bit dummy checksum? # a random 32-bit int, repeated 32-bit length, keytype # the private key (including public) 32-bit length, pub0 # Public Key parts 32-bit length, pub1 32-bit length, prv0 # Private Key parts ... # (number varies by type) 32-bit length, comment # comment string padding bytes 0x010203 # pad to blocksize

Implementation

static Uint8List loadPrivateKeyFromOpenSSHPem(String pemFileContent,
    {String? password}) {
  if (!pemFileContent.startsWith(openSshHeader) ||
      !pemFileContent.startsWith(openSshHeader)) {
    throw Exception('Wrong file format');
  }

  pemFileContent = pemFileContent.replaceAll(RegExp(r'[\n\r]'), '');
  pemFileContent = pemFileContent.substring(openSshHeader.length).trimLeft();
  pemFileContent = pemFileContent
      .substring(0, pemFileContent.length - openSshFooter.length)
      .trimRight();

  var binaryContent =
      base64.decode(pemFileContent.replaceAll(RegExp(r'[\n\r]'), ''));
  var header = binaryContent.sublist(0, binaryContent.indexOf(0));
  if (String.fromCharCodes(header) == 'openssh-key-v1') {
    var readerIndex = header.length + 1;
    var cypherNameLength = _readOpenSshKeyUInt32(binaryContent, readerIndex);
    readerIndex += 4;
    var cypherName =
        _readOpenSshKeyString(binaryContent, readerIndex, cypherNameLength);
    readerIndex += cypherNameLength;
    var keyDerivationFunctionNameLength =
        _readOpenSshKeyUInt32(binaryContent, readerIndex);
    readerIndex += 4;
    var keyDerivationFunctionName = _readOpenSshKeyString(
        binaryContent, readerIndex, keyDerivationFunctionNameLength);
    readerIndex += keyDerivationFunctionNameLength;
    var keyDerivationFunctionOptionsLength =
        _readOpenSshKeyUInt32(binaryContent, readerIndex);
    readerIndex += 4;
    //keyDerivationFunctionLength should be 0 for no kdf
    var keyDerivationFunctionOptions = binaryContent.sublist(
        readerIndex, readerIndex + keyDerivationFunctionOptionsLength);
    readerIndex += keyDerivationFunctionOptionsLength;
    var keyCount = _readOpenSshKeyUInt32(binaryContent, readerIndex);
    if (keyCount != 1) {
      throw Exception('Only single key files are supported for now!');
    }
    readerIndex += 4; //key count should always be 1
    var publicKeyLength = _readOpenSshKeyUInt32(binaryContent, readerIndex);
    readerIndex += 4 + publicKeyLength;
    var privateKeyLength = _readOpenSshKeyUInt32(binaryContent, readerIndex);
    readerIndex += 4;
    var privateKeyIndex = readerIndex;
    if (keyDerivationFunctionName == 'none') {
      return _readOpenSshPrivateKeySeed(binaryContent, readerIndex);
    } else if (keyDerivationFunctionName == 'bcrypt') {
      if (password == null || password.isEmpty) {
        throw Exception('No password supported for encrypted file');
      }
      var keyIv = Uint8List(48);
      var pbkdfSaltLength =
          _readOpenSshKeyUInt32(keyDerivationFunctionOptions, 0);
      BcryptPbkdf.pbkdf(
          password,
          keyDerivationFunctionOptions.sublist(4, 4 + pbkdfSaltLength),
          _readOpenSshKeyUInt32(
              keyDerivationFunctionOptions, 4 + pbkdfSaltLength),
          keyIv);
      var key = keyIv.sublist(0, 32);
      var iv = keyIv.sublist(32, 48);
      late BlockCipher cypher;
      if (cypherName == 'aes256-ctr') {
        cypher = CTRBlockCipher(32, CTRStreamCipher(AESEngine()))
          ..init(false, ParametersWithIV(KeyParameter(key), iv));
      } else if (cypherName == 'aes256-cbc') {
        cypher = CBCBlockCipher(AESEngine())
          ..init(false, ParametersWithIV(KeyParameter(key), iv));
      }

      // Decrypt the cipherText block-by-block

      final paddedPlainText = Uint8List(privateKeyLength); // allocate space
      final cipherText = binaryContent.sublist(
          privateKeyIndex, privateKeyIndex + privateKeyLength);

      var offset = 0;
      while (offset < privateKeyLength) {
        offset +=
            cypher.processBlock(cipherText, offset, paddedPlainText, offset);
      }
      assert(offset == privateKeyLength);

      return _readOpenSshPrivateKeySeed(paddedPlainText, 0);
    } else {
      throw Exception('The given cypherName $cypherName is not supported!');
    }
  } else {
    throw Exception('This is not a valid open ssh key file format!');
  }
}