理解OpenStack认证：Keystone PKI

原文链接： https://www.mirantis.com/blog/understanding-openstack-authentication-keystone-pki/

The latest stable release of OpenStack, codenamed Grizzly, revolutionizes the way user authentication works. You 

may have read some of the few articles available on this new authentication scheme. This post attempts to capture 

the full scope of this new feature. It focuses not on how Keystone issues tokens but rather the later stage, where 

existing tokens are used by clients to sign their API calls. These requests are later validated by OpenStack API 

endpoints. You’ll see first why you need tokens and then how PKI tokens can be used by OpenStack API endpoints 

to conduct user token verification without explicit calls to Keystone. We begin by explaining how clients connect to 

OpenStack.

OpenStack, APIs, and clients

So where does OpenStack begin and end? The users will say that it’s their cloud GUI or CLI. From the architectural 

perspective, however, OpenStack middleware ends on its API endpoints: nova-api, glance-api, and so on—they all 

expose their APIs over http. You can connect to these APIs using different clients. Clients can be either certified by 

a cloud vendor and deployed on its infrastructure (for example, a Horizon instance) or installed anywhere else (a 

python-novaclient installed on any laptop, pointing to a remote nova-api).

This boundary implies one important condition. Since the clients can reside anywhere, they cannot be trusted. Any 

request coming from them to any OpenStack API endpoint needs to be authenticated before it can be processed 

further.

Tokens—what they are and why you need them

So what do you have to do in this case? Does that mean you should supply each single API request with a 

username and password? Not so easy. Or maybe store them in some environment variables? Insecure. The answer 

to this is tokens. Tokens have one significant plus: they are temporary and short lived, which means it is safer to 

cache them on clients than username/password pairs.

In general, a token is a piece of data given to a user by Keystone upon providing a valid username/password 

combination. As said above, what is closely related to a token is its expiration date (which typically is hours or even 

minutes). The user client can cache the token and inject it into an OpenStack API request. The OpenStack API 

endpoints take the token out of user requests and validate it against the Keystone authentication backend, thereby 

confirming the legitimacy of the call.

We’ll now turn your attention to two token approaches—Universally Unique IDentifier (UUID) and Public Key 

Infrastructure (PKI) tokens—and their evolution, so to speak.

UUID tokens (Folsom and older)

The diagram below shows how tokens were originally generated by Keystone and then used by the client to “sign” 

every subsequent API request.

Based on supplied username/password pair (we assume it’s correct in this scenario and on the diagram):

• Keystone would:
  • Generate a UUID token.
  • Store the UUID token in its backend.
  • Send a copy of the UUID token back to the client.
• The client would cache the token.
• The UUID would be then passed along with each API call by the client.
• Upon each user request, the API endpoint would send this UUID back to Keystone for validation.
• Keystone would take the UUID and match it against its auth backend (check UUID string, expiration date).
• Keystone would return “success” or “failure” message to the API endpoint.

As you can see from the above diagram, for each user call the API endpoints need to conduct online verification 

with the Keystone service. Imagine thousands of clients performing VM listings, network creation, and so on. This 

activity results in extensive traffic to the Keystone service. In fact, in production, Keystone proves to be one of the 

most loaded OpenStack services on the network side, but Grizzly gets rid of this problem quite nicely.

Enter PKI tokens.

PKI tokens (Grizzly and on)

The diagram below shows how token validation is performed with the new method introduced in OpenStack’s 

Grizzly release.

In general terms, with PKI tokens, Keystone is becoming a Certificate Authority (CA). It uses its signing key and 

certificate to sign (not encrypt) the user token.

On top of that, each API endpoint holds a copy of Keystone’s:

• Signing certificate
• Revocation list
• CA certificate

The API endpoints use these bits to validate the user requests. There is no need for direct request to Keystone with 

each validation. What is verified instead is the signature Keystone puts on the user token and Keystone’s 

revocation list. API endpoints use the above data to carry out this process offline.

PKI tokens under the hood

To use PKI tokens in Grizzly, we need to generate all the keys and certs. We can do that using the following 

command:

keystone-manage pki_setup

This command generates the following files:

• CA private key

  openssl genrsa -out /etc/keystone/ssl/certs/cakey.pem 1024 -config /etc/keystone/ssl/certs/openssl.conf

• CA certificate

  openssl req -new -x509 -extensions v3_ca -passin pass:None -key /etc/keystone/ssl/certs/cakey.pem -out /etc/keystone/ssl/certs/ca.pem -days 3650 -config /etc/keystone/ssl/certs/openssl.conf -subj /C=US/ST=Unset/L=Unset/O=Unset/CN=www.example.com

• Signing private key

• openssl genrsa -out /etc/keystone/ssl/private/signing_key.pem 1024 -config /etc/keystone/ssl/certs/openssl.conf

• Signing certificate

  openssl req -key /etc/keystone/ssl/private/signing_key.pem -new -nodes -out /etc/keystone/ssl/certs/req.pem -config /etc/keystone/ssl/certs/openssl.conf -subj /C=US/ST=Unset/L=Unset/O=Unset/CN=www.example.com
  openssl ca -batch -out /etc/keystone/ssl/certs/signing_cert.pem -config /etc/keystone/ssl/certs/openssl.conf -infiles /etc/keystone/ssl/certs/req.pem

Token generation and format

With PKI, Keystone now uses Cryptographic Message Syntax (CMS). Keystone produces CMS token out of the 

following data:

• Service catalog
• User roles
• Metadata

An example of the input data follows:

{
   "access": {
       "metadata": {
           ....metadata goes here....
       },
       "serviceCatalog": [
           ....endpoints goes here....
       ],
       "token": {
           "expires": "2013-05-26T08:52:53Z",
           "id": "placeholder",
           "issued_at": "2013-05-25T18:59:33.841811",
           "tenant": {
               "description": null,
               "enabled": true,
               "id": "925c23eafe1b4763933e08a4c4143f08",
               "name": "user"
           }
       },
       "user": {
           ....userdata goes here....
       }
   }
}

The CMS token is just the above metadata in CMS format, signed with Keystone’s signing key. It typically takes the 

form of a lengthy, seemingly random string:

MIIDsAYJKoZIhvcNAQcCoIIDoTCCA50CAQExCTAHBgUrDgMCGjCCAokGCSqGSIb3DQEHAaCCAnoEggJ2ew0KICAgICJhY2Nlc3MiOiB7DQogICAgICAgICJtZXRhZGF0YSI6IHsNCiAgICAgICAgICAgIC4uLi5tZXRhZGF0YSBnb2VzIGhlcmUuLi4uDQogICAgICAgIH0sDQogICAgICAgICJzZXJ2aWNlQ2F0YWxvZyI6IFsNCiAgICAgICAgICAgIC4uLi5lbmRwb2ludHMgZ29lcyBoZXJlLi4uLg0KICAgICAgICBdLA0KICAgICAgICAidG9rZW4iOiB7DQogICAgICAgICAgICAiZXhwaXJlcyI6ICIyMDEzLTA1LTI2VDA4OjUyOjUzWiIsDQogICAgICAgICAgICAiaWQiOiAicGxhY2Vob2xkZXIiLA0KICAgICAgICAgICAgImlzc3VlZF9hdCI6ICIyMDEzLTA1LTI1VDE4OjU5OjMzLjg0MTgxMSIsDQogICAgICAgICAgICAidGVuYW50Ijogew0KICAgICAgICAgICAgICAgICJkZXNjcmlwdGlvbiI6IG51bGwsDQogICAgICAgICAgICAgICAgImVuYWJsZWQiOiB0cnVlLA0KICAgICAgICAgICAgICAgICJpZCI6ICI5MjVjMjNlYWZlMWI0NzYzOTMzZTA4YTRjNDE0M2YwOCIsDQogICAgICAgICAgICAgICAgIm5hbWUiOiAidXNlciINCiAgICAgICAgICAgIH0NCiAgICAgICAgfSwNCiAgICAgICAgInVzZXIiOiB7DQogICAgICAgICAgICAuLi4udXNlcmRhdGEgZ29lcyBoZXJlLi4uLg0KICAgICAgICB9DQogICAgfQ0KfQ0KMYH/MIH8AgEBMFwwVzELMAkGA1UEBhMCVVMxDjAMBgNVBAgTBVVuc2V0MQ4wDAYDVQQHEwVVbnNldDEOMAwGA1UEChMFVW5zZXQxGDAWBgNVBAMTD3d3dy5leGFtcGxlLmNvbQIBATAHBgUrDgMCGjANBgkqhkiG9w0BAQEFAASBgEh2P5cHMwelQyzB4dZ0FAjtp5ep4Id1RRs7oiD1lYrkahJwfuakBK7OGTwx26C+0IPPAGLEnin9Bx5Vm4cst/0+COTEh6qZfJFCLUDj5b4EF7r0iosFscpnfCuc8jGMobyfApz/dZqJnsk4lt1ahlNTpXQeVFxNK/ydKL+tzEjg

The command used for this is:

openssl cms -sign -signer /etc/keystone/ssl/certs/signing_cert.pem -inkey /etc/keystone/ssl/private/signing_key.pem -outform PEM -nosmimecap -nodetach -nocerts -noattr

Token verification and expiration

As the diagram shows, PKI tokens enable Openstack API endpoints to conduct offline verification of token validity 

by checking Keystone’s signature.

Three things should be validated:

• Token signature
• Token expiration date
• Whether the token has been deleted (revoked)

CHECKING TOKEN SIGNATURE

In order to do check the signature, all of the API endpoints need Keystone certs. These files can be obtained 

directly from the Keystone Service:

curl http://[KEYSTONE IP]:35357/v2.0/certificates/signing
curl http://[KEYSTONE IP]:35357/v2.0/certificates/ca

If the API service cannot find these files on its local disk, it will automatically download them from Keystone. The 

following command is used to verify the signature on the token:

openssl cms -verify -certfile /tmp/keystone-signing-nova/signing_cert.pem -CAfile /tmp/keystone-signing-nova/cacert.pem -inform PEM -nosmimecap -nodetach -nocerts -noattr < cms_token

If the signature is valid, the above command returns the metadata contained in CMS, which is further consumed by 

the API endpoint.

CHECKING TOKEN EXPIRATION DATE

One of the extracted metadata fields is token’s expiration date, which is compared against current time.

HANDLING DELETED TOKENS

The deletion of tokens is enforced by putting a given token onto a revocation list within the Keystone CA. By 

default, this list is being updated (pulled from Keystone) by API endpoints every second from the following URL:

curl http://[KEYSTONE IP]:35357/v2.0/tokens/revoked

The form of the list is a plain json file:

{
   "revoked": [
       {
           "expires": "2013-05-27T08:31:37Z",
           "id": "aef56cc3d1c9192b0257fba1a420fc37"
       }
    …
   ]
}

While “expires” field does not need further explanation, the “id” field looks somewhat cryptic. It is the md5 hash 

calculated out of the CMS user token: md5(cms_token). API endpoints also calculate md5 hashes out of CMS 

token received with user requests and search the matching md5-s on the “revoked” list. If no match is found, then 

the token is considered to be valid.

Summary

OpenStack API endpoints can use PKI tokens to conduct user token verification without explicit calls to Keystone. 

This can positively impact Keystone performance in the case of large installations where the number of user calls to 

OpenStack APIs can be overwhelming. One caveat, however: PKI does not guarantee privacy of the tokens. It is 

only used for signing, and not encryption. If you want to prevent tokens from being hijacked, you should secure all 

of the API endpoints using the HTTPS protocol.