This file contains the GPG keys of Apache Daffodil developers.

Users:    gpg --import KEYS

Developers:
  Create a key: 
    Per Apache guidelines (https://www.apache.org/dev/openpgp.html#key-gen-generate-key)
      - RSA and RSA key with keysize 4096, and no expiration
      - Use your apache email
    
    gpg --full-generate-key


  Adding your key to this file:
    (gpg --list-sigs <key id> && gpg --armor --export <key id>) >> this file.

  Publish the key:
    gpg --keyserver pgp.mit.edu --send-keys <key id>

  Signing another developers key:
    gpg --keyserver pgp.mit.edu --search-keys <name or email>
    gpg --keyserver pgp.mit.edu --recv-keys <key id>
    gpg --sign-key <key id>
    gpg --keyserver pgp.mit.edu --send-keys <key id>

  Additional Information:
    http://www.apache.org/dev/openpgp.html#generate-key

********************************* PLEASE NOTE **********************************

  Releases will be signed using one of the keys in this file. This file will
  be available with the distributed Apache Daffodil releases at:

      https://dist.apache.org/repos/dist/release/daffodil/KEYS

********************************************************************************

pub   4096R/033AE661 2018-01-22
uid                  Steve Lawrence <slawrence@apache.org>
sig 3        033AE661 2018-01-22  Steve Lawrence <slawrence@apache.org>
sub   4096R/66058329 2018-01-22
sig          033AE661 2018-01-22  Steve Lawrence <slawrence@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
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=cYZZ
-----END PGP PUBLIC KEY BLOCK-----

pub   4096R/13A680AF 2018-08-16
uid                  Michael J. Beckerle (Code Signing Key) <mbeckerle@apache.org>
sig 3        13A680AF 2018-08-16  Michael J. Beckerle (Code Signing Key) <mbeckerle@apache.org>
sub   4096R/CD901D55 2018-08-16
sig          13A680AF 2018-08-16  Michael J. Beckerle (Code Signing Key) <mbeckerle@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1
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=09Ch
-----END PGP PUBLIC KEY BLOCK-----
pub   rsa4096 2020-04-01 [SC]
      EA0B5228201A90CD1BBCE006639637FDA8049411
uid           [ultimate] Olabusayo Kilo <olabusayo@apache.org>
sig 3        639637FDA8049411 2020-04-01  Olabusayo Kilo <olabusayo@apache.org>
sub   rsa4096 2020-04-01 [E]
sig          639637FDA8049411 2020-04-01  Olabusayo Kilo <olabusayo@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
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=Grso
-----END PGP PUBLIC KEY BLOCK-----
