Commit ecd07d22 authored by Vincent Pelletier's avatar Vincent Pelletier

all: Major rework.

- Re-evaluate feature set and REST API.
- switch duration units to days, which are more meaningful than sticking to
  ISO units in this context.
- Implement the "cau" half of "caucase".
  As a consequence flask password authentication mechanism is not needed
  anymore. As HTML UI is not required internally to caucase, and as
  sqlalchemy is not used to its full extend, get rid of these
  dependencies altogether.
- Implement REST HTTP/HTTPS stand-alone server as a layer above WSGI
  application, and integrate HTTPS certificate issuance and renewal
  mechanism to simplify deployment: no middleware needed, so from
  gunicorn dependency.
- Use standard python modules for http client needs.
- Re-evaluate data retention options:
  - unsigned CSRs are kept forever
  - CRTs are stored in CSR table, and a 24 hour expiration is set
  - CA CRTs: (unchanged, expire when past validity period)
  - CRLs: (unchanged, expire when past validity period)
- Redispatch housekeeping tasks:
  - CA renewal happens when caucase is used and renewal is needed
  - CRL is flushed when re-generated
  - CSR table (containing CRTs) is cleaned when a new CSR is received
  removing completely the need for these special periodic tasks.
- Storage parameters are not stored persistently anymore, instead their
  effect (time offsets) is applied before storing (to protect against
  transient retention period reconfiguration from wiping data).
- Rework storage schema.
- Implement certificate extension propagation & filtering.
- Implement "Certificate was auto-signed" extension.
- More docstrings.
- Use a CSR as a subject & extensions template instead of only allowing
  to override the subject. Useful when renewing a certificate and when
  authenticated client wants to force (ex) a CommonName in the subject.
- Reorganise cli executable arguments to have more possible actions.
  Especially, make CA renewal systematic on command start (helps
  validating caucase URL).
- Increase the amount of sanity checks against user-provided data (ex:
  do not upload a private key which would be in the same file as the CRT
  to renew).
- Extend package classifiers.
- Get rid of revocation reason, as it seems unlikely to be filled, and
  even less likely to be read later.
- (almost) stop using pyOpenSSL. Use cryptography module instead.
  cryptography has many more features than pyOpenSSL (except for certificate
  validation, sadly), so use it. It completely removes the need to poke
  at ASN.1 ourselves, which significantly simplifies utils module, and
  certificate signature. Code is a bit more verbose when signing, but much
  simpler than before.
- add the possibility to revoke by certificate serial
- update gitignore
- include coverage configuration
- include pylint configuration
- integrate several secondary command:
  - caucase-probe to quickly check server presence and basic
    functionality, so automated deployments can easily auto-check
  - caucase-monitor to automate key initial request and renewal
  - caucase-rerequest to allow full flexibility over certificate request
    content without ever transfering private keys
- add a secure backup generation mechanism
- add a README describing the design
parent 0da27fdc
[run]
branch = true
concurrency =
thread
multiprocessing
parallel = true
/htmlcov/
/cover/
/.eggs/
/.coverage
.*.swp
*.pyc
[MESSAGES CONTROL]
disable=C0103,C0330
# C0103 Disable "Invalid name "%s" (should match %s)"
# C0330 Disable "bad-continuation"
[FORMAT]
indent-string=" "
0.2.0 (2017-08-XX)
==================
* implement the "cau" half of "caucase"
* massive rework: removal of flask dependency, removal of HTML UI, rework of
the REST API, rework of the CLI tools, rework of the WGSI application,
incomatible redesign of the database.
0.1.4 (2017-07-21)
==================
* caucase web parameter 'auto-sign-csr-amount' can be used to set how many csr must be signed automatically.
......
include CHANGES.txt
recursive-include caucase/templates *.html
recursive-include caucase/static *.css *.png *.js *.gif
include COPYING
=======
caucase
=======
Certificate Authority for Users, Certificate Authority for SErvices
Overview
========
The goal of caucase is to automate certificate issuance and renewal without
constraining how the certificate will be used.
For example, there is no assumption that the certificate will be used to
secure HTTP, nor to serve anything at all: you may need certificates to
authenticate users, or sign your mails, or secure an SQL server socket.
As an unfortunate consequence, it is not possible for caucase to automatically
validate a signing request content against a service (ex: as one could check
the certificate for an HTTPS service was requested by someone with the ability
to make it serve a special file).
This also means that, while caucase imposes RFC-recommended constraints on many
certificate fields and extensions to be worthy of trust, it imposes no
constraint at all on subject and alternate subject certificate fields.
To still allow certificates to be used, caucase uses itself to authenticate
users (humans or otherwise) who implement the validation procedure: they tell
caucase what certificates to emit. Once done, any certificate can be
prolungated at a simple request of the key holder while the to-renew
certificate is still valid (not expired, not revoked).
Bootstrapping the system (creating the first service certificate for
_`caucased` to operate on HTTPS, and creating the first user certificate to
control further certificate issuance) works by caucase automatically signing a
set number of certificates upon submission.
Vocabulary
==========
Caucase manipulates the following asymetric cryptography concepts.
- Key pair: A private key and corresponding public key. The public key can be
derived from the private key, but not the other way around. As a consequence,
the private key is itself considered to be a key pair.
- Certificate: A certificate is the assurante, by a certificate authority,
that a given public key and set of attributes belong to an authorised entity.
Abbreviated cert or crt. A certificate is by definition signed by a CA.
- Certificate Authority: An entry, arbitrarily trusted (but worthy of trust by
its actions and decision) which can issue certificates. Abbreviated CA.
- Certificate signing request: A document produced by an entity desiring to get
certified, which they send to a certificate authority. The certificate signing
request contains the public key and desired set of attributes that the CA
should pronounce itself on. The CA has all liberty to issue a different set
of attiributes, or to not issue a certificate.
- Certificate revocation list: Lists the certificates which were issued by a CA
but which should not be trusted annymore. This can happen for a variety of
reasons: the private key was compromised, or its owneing entity should not be
trusted anymore (ex: entity's permission to access to protected service was
revoked).
- PEM: A serialisation mechanism commonly used for various cryptographic data
pieces. It relies on base64 so it is 7-bits-safe (unlike DER), and is very
commonly supported. Caucase exclusively uses PEM format.
Validity period
===============
Cryptographic keys wear out as are used and and as they age.
Of course, they do not bit-rot nor become thinner with use. But each time one
uses a key and each minute an attacker had access to a public key, fractions
of the private key bits are inevitably leaked, weakening it overall.
So keys must be renewed periodically to preserve intended security level. So
there is a limited life span to each certificate, including the ones emitted by
caucase.
The unit duration for caucase-emitted certificates is the "normal" certificate
life span. It default to 93 days from the moment the certificate was signed,
or about 3 months.
Then the CA certificate has a default life span of 4 "normal" certificate
validity periods. As CA renewal happens in caucase without x509-level cross
signing (by decision, to avoid relying on intermediate CA support on
certificate presenter side and instead rely on more widespread
multi-CA-certificate support on virifier side), there is a hard lower bound of
3 validity periods, under which the CA certificate cannot be reliably renewed
without risking certificate validation issues for emitted "normal"
certificates. CA certificate renewal is composed of 2 phases:
- Passive distribution phase: current CA certificate has a remaining life span
of less than 2 "normal" certificate life spans: a new CA certificate is
generated and distributed on-demand (on "normal" certificate renewal and
issuance, on CRL retrieval with caucase tools...), but not used to sign
anything.
- Active use phase: new CA certificate is valid for more than one "normal"
certificate life span. This means that all existing certificates which are
still in active use had to be renewed at least once since the new CA
certificate exists. This means all the certificate holders had the
opportunity to learn about the new CA certificate. So the new CA certificate
starts being used to sign new certificates, and the old CA certificate falls
out of use as its signed "normal" certificates expire.
By default, all caucase tools will generate a new private key unrelated to the
previous one on each certificat renewal.
Lastly, there is another limited validity period, although not for the same
reasons: the list of revoked certificates also has a maximum life span. In
caucase, the CRL is re-generated whenever it is requested and:
- there is no previous CRL
- previous CRL expired
- any revocation happened since previous CRL was created
Commands
========
Caucase provides several commands to work with certificates.
caucase
+++++++
Reference caucase "one-shot" client.
This command is intended to be used for isolated actions:
- listing and signing pending certificate signature requests
- revoking certificates
It is also able to submit certificate signing requests, retrieve signed
certificates, requesting certificate renewals and updating both
CA certificates and revocation lists, but you may be interested in using
_`caucase-monitor` for this instead.
caucase-monitor
+++++++++++++++
Reference caucase certificate renewal daemon.
Monitors a key pair, corresponding CA certificate and CRL, and renew them
before expiration.
When the key-pair lacks a signed certificate, issues a pre-existing CSR to
caucase server and waits for the certificate to be issued.
caucase-probe
+++++++++++++
Caucase server availability tester.
Performs minimal checks to verify a caucase server is available at given URL.
caucase-rerequest
+++++++++++++++++
Utility allowing to re-issue a CSR using a locally-generated private key.
Intended to be used in conjunction with _`caucase-monitor` when user cannot
generate the CSR on the system where the certificate is desired (ex: automated
HTTPS server deployment), where user is not the intended audience for
caucase-produced certificate:
- User generates a CSR on their own system, and signs it with any key (it will
not be needed later
- User sends the CSR to the system where the certificate is desired
- User gets caucase-rerequest to run on this CSR, producing a new private key
and a CSR similar to issued one, but signed with this new private key
- From then on, caucase-monitor can take over
This way, no private key left their original system, and user could still
freely customise certificate extensions.
caucase-key-id
++++++++++++++
Utility displaying the identifier of given key, or the identifier of keys
involved in given backup file.
Allows identifying users which hold a private key candidate for restoring a
caucased backup (see _`Restoration procedure`).
caucased
++++++++
Reference caucase server daemon.
This daemon provides access to both CAU and CAS services over both HTTP and
HTTPS.
It handles its own certificate issuance and renewal, so there is no need to use
_`caucase-monitor` for this service.
Backups
-------
Loosing the CA private key prevents issuing any new certificate trusted by
services which trusted the CA. Also, it prevents issuing any new CRL.
Recovering from such total loss requires starting a new CA and rolling it out
to all services which used the previous one. This is very time-costly.
So backups are required.
On the other hand, if someone gets their hand on the CA private key, they can
issue certificates for themselves, allowing them to authenticate with services
trusting the CA managed by caucase - including caucased itself if they issue a
user certificate: they can then revoke existing certificates and cause a lot of
damage.
So backups cannot happen in clear text, they must be encrypted.
But the danger of encrypted backups is that by definition they become worthless
if they cannot be decrypted. So as many (trusted) entities as possible should
be granted the ability to decrypt the backups.
The solution proposed by caucased is to encrypt produced backups in a way which
allows any of the caucase users to decrypt the archive.
As these users are already entrusted with issuing certificates, this puts
only a little more power in their hands than they already have. The little
extra power they get is that by having unrestricted access to the CA private
key they can issue certificates bypassing all caucase restrictions. The
proposed parade is to only make the backups available to a limited subset of
caucase users when there is an actual disaster, and otherwise keep it out of
their reach. This mechanism is not handled by caucase.
As there are few trusted users, caucase can keep their still-valid certificates
in its database for the duration of their validity with minimal size cost.
Backup procedure
----------------
Backups happen periodically as long as caucased is running. See
`--backup-period` and `--backup-directory`.
As discussed above, produced files should be kept out of reach of caucase
users until a disaster happens.
Restoration procedure
---------------------
See `--restore-backup`.
To restore, one of the trusted users must voluntarily compromise their own
private key, providing it to the administrator in charge of the restoration
procedure. Restoration procedure will hence immediately revoke their
certificate. They must also provide a CSR generated with a different private
key, so that caucase can provide them with a new certificate, so they keep
their access only via different credentials.
- admin identifies the list of keys which can decipher a backup, and broadcasts
that list to key holders
- key holders manifest themselves
- admin picks a key holder, requests them to provide their eixsting private key
and to generate a new key and accompanying csr
- key holder provide requested items
- admin initiates restoration with `--restore-backup` and provides key holder
with the csr_id so they can fetch their new certificate using caucase
protocol
Backup file format
------------------
- 64bits: 'caucase\0' magic string
- 32bits LE: header length
- header: json-encoded header (see below)
- encrypted byte stream (aka payload)
Header schema (inspired from s/mime, but s/mime tools available do not
support at least iterative production or iterative generation)::
{
"description": "Caucase backup header",
"required": ["algorithm", "key_list"],
"properties": {
"cipher": {
"description": "Symetric ciher used for payload",
"required": ["name"],
"properties": {
"name":
"enum": ["aes256_cbc_pkcs7_hmac_10M_sha256"],
"type": "string"
},
"parameter": {
"description": "Name-dependend clear cipher parameter (ex: IV)",
"type": "string"
}
}
"type": "object"
},
"key_list": {
"description": "Content key, encrypted with public keys",
"minItems": 1,
"items": {
"required": ["id", "cipher", "key"],
"properties": {
"id": {
"description": "Hex-encoded sha1 hash of the public key",
"type": "string"
},
"cipher": {
"description": "Asymetric cipher used for symetric key",
"required": ["name"],
"properties": {
"name": {
"enum": ["rsa_oaep_sha1_mgf1_sha1"],
"type": "string"
}
},
"type": "object"
}
"key": {
"description": "Hex-encoded encrypted concatenation of signing and symetric encryption keys",
"type": "string"
}
},
"type": "object"
},
"type": "array"
}
},
"type": "object"
}
Blocker for 1.0
===============
- After pyca/cryptography 21st release: Make is_signature_valid call mandatory in caucase.utils.load_crl .
- After pyca/cryptography later release (code not fixed yet): Enable CRL distribution point extension when it tolerates literal IPv6 in the URL.
Eventually
==========
- Become an OCSP responder (requires support in other libraries - likely pyca/cryptography).
......@@ -15,23 +15,6 @@
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
# See http://peak.telecommunity.com/DevCenter/setuptools#namespace-packages
try:
__import__('pkg_resources').declare_namespace(__name__)
except ImportError:
from pkgutil import extend_path
__path__ = extend_path(__path__, __name__)
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
# Use default value so SQLALCHEMY will not warn because there is not db_uri
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///ca.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
from caucase import web, storage
\ No newline at end of file
"""
Caucase - Certificate Authority for Users, Certificate Authority for SErvices
"""
# -*- coding: utf-8 -*-
# This file is part of caucase
# Copyright (C) 2017 Nexedi
# Alain Takoudjou <alain.takoudjou@nexedi.com>
......@@ -16,541 +15,907 @@
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
"""
Caucase - Certificate Authority for Users, Certificate Authority for SErvices
"""
from __future__ import absolute_import
import datetime
import json
import os
import sys
import subprocess
import re
import time
import uuid
import errno
import tempfile
from OpenSSL import crypto, SSL
import traceback
from pyasn1.codec.der import encoder as der_encoder
from pyasn1.type import tag
from pyasn1_modules import rfc2459
from datetime import datetime, timedelta
from caucase.exceptions import (ExpiredCertificate, NotFound,
BadCertificateSigningRequest, CertificateVerificationError)
from caucase import utils
MIN_CA_RENEW_PERIOD = 2
DEFAULT_DIGEST_LIST = ['sha256', 'sha384', 'sha512']
SUBJECT_KEY_LIST = ['C', 'ST', 'L', 'OU', 'O', 'CN', 'emailAddress']
def getX509NameFromDict(**name_dict):
import struct
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization, hashes, hmac
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives.asymmetric.padding import OAEP, MGF1
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from . import utils
from .exceptions import CertificateVerificationError
__all__ = ('CertificateAuthority', )
_cryptography_backend = default_backend()
_AUTO_SIGNED_NO = 0
_AUTO_SIGNED_YES = 1
_AUTO_SIGNED_PASSTHROUGH = 2
_SUBJECT_OID_DICT = {
# pylint: disable=bad-whitespace
'C' : x509.oid.NameOID.COUNTRY_NAME,
'O' : x509.oid.NameOID.ORGANIZATION_NAME,
'OU': x509.oid.NameOID.ORGANIZATIONAL_UNIT_NAME,
'ST': x509.oid.NameOID.STATE_OR_PROVINCE_NAME,
'CN': x509.oid.NameOID.COMMON_NAME,
'L' : x509.oid.NameOID.LOCALITY_NAME,
'SN': x509.oid.NameOID.SURNAME,
'GN': x509.oid.NameOID.GIVEN_NAME,
# pylint: enable=bad-whitespace
}
_BACKUP_MAGIC = 'caucase\0'
_CONFIG_NAME_AUTO_SIGN_CSR_AMOUNT = 'auto_sign_csr_amount'
def Extension(value, critical):
"""
Return a new X509Name with the given attributes.
Avoid oid redundant parameter when creating an extension.
"""
# XXX There's no other way to get a new X509Name.
name = crypto.X509().get_subject()
for key, value in name_dict.items():
setattr(name, key, value)
return name
return x509.Extension(
oid=value.oid,
critical=critical,
value=value,
)
class CertificateAuthority(object):
def __init__(self, storage, ca_life_period, ca_renew_period,
crt_life_time, crl_renew_period, digest_list=None,
crl_base_url=None, ca_subject='',
max_csr_amount=50, crt_keep_time=0,
auto_sign_csr_amount=0):
self._storage = storage
self.ca_life_period = ca_life_period
self.digest_list = digest_list
self.crt_life_time = crt_life_time
self.crl_renew_period = crl_renew_period
self.ca_renew_period = ca_renew_period
self.default_digest = 'sha256'
self.crl_base_url = crl_base_url
self.auto_sign_csr_amount = auto_sign_csr_amount
self.extension_manager = utils.X509Extension()
self.mandatory_subject_key_list = ['CN']
self.ca_subject_dict = self._getCASubjectDict(ca_subject)
# XXX - ERR_SSL_SERVER_CERT_BAD_FORMAT on browser
# Because if two certificate has the same serial from a CA with the same CN
# self.ca_subject_dict['CN'] = '%s %s' % (self.ca_subject_dict['CN'], int(time.time()))
if not self.digest_list:
self.digest_list = DEFAULT_DIGEST_LIST
if self.ca_life_period < MIN_CA_RENEW_PERIOD:
raise ValueError("'ca_life_period' value should be upper than %s" % MIN_CA_RENEW_PERIOD)
if self.crl_renew_period > 1:
raise ValueError("'crl_renew_period' is too high and should be less than a certificate life time.")
self.crl_life_time = int(self.crt_life_time * self.crl_renew_period)
self.ca_life_time = int(self.crt_life_time * self.ca_life_period)
self.ca_renew_time = int(self.crt_life_time * self.ca_renew_period)
self._ca_key_pairs_list = self._storage.getCAKeyPairList()
if not self._ca_key_pairs_list:
self.createCAKeyPair()
def _getCASubjectDict(self, ca_subject):
"""
Parse CA Subject from provided sting format
Ex: /C=XX/ST=State/L=City/OU=OUnit/O=Company/CN=CA Auth/emailAddress=xx@example.com
"""
ca_subject_dict = {}
regex = r"\/([C|ST|L|O|OU|CN|emailAddress]+)=([\w\s\@\.\d\-_\(\)\,\+:']+)"
matches = re.finditer(regex, ca_subject)
for match in matches:
key = match.group(1)
if not key in SUBJECT_KEY_LIST:
raise ValueError("Item %r is not a valid CA Subject key, please" \
"Check that the provided key is in %s" % (key,
SUBJECT_KEY_LIST))
ca_subject_dict[key] = match.group(2)
for key in self.mandatory_subject_key_list:
if key not in ca_subject_dict:
raise ValueError("The subject key '%r' is mandatory." % key)
return ca_subject_dict
def renewCAKeyPair(self):
"""
Refresh instance's knowledge of database content
(as storage house-keeping may/will happen outside our control)
"""
This class implements CA policy and lifetime logic:
- how CA key pair is generated
- what x509.3 extensions and attributes are enforced on signed certificates
- CA and CRL automated renewal
"""
def __init__(
self,
storage,
ca_subject_dict=(),
ca_key_size=2048,
crt_life_time=31 * 3, # Approximately 3 months
ca_life_period=4, # Approximately a year
crl_renew_period=0.33, # Approximately a month
crl_base_url=None,
digest_list=utils.DEFAULT_DIGEST_LIST,
auto_sign_csr_amount=0,
lock_auto_sign_csr_amount=False,
):
"""
storage (caucase.storage.Storage)
Persistent storage of certificate authority data.
ca_subject_dict (dict)
Items to use as Certificate Authority certificate subject.
Supported keys are: C, O, OU, ST, CN, L, SN, GN.
ca_key_size (int)
Number of bits to use as Certificate Authority key.
crt_life_time (float)
Validity duration for every issued certificate, in days.
ca_life_period (float)
Number of crt_life_time periods for which Certificate Authority
certificate will be valid.
Must be greater than 3 to allow smooth rollout.
crl_renew_period (float)
Number of crt_life_time periods for which a revocation list is
valid for.
crl_base_url (str)
The CRL distribution URL to include in signed certificates.
None to not declare a CRL distribution point in generated certificates.
Revocations are be functional even if this is None.
digest_list (list of str)
List of digest algorithms considered acceptable for authenticating
renewal and revocation requests, and CA renewal list responses.
The first item will be the one used, others are accepted but not used.
auto_sign_csr_amount (int)
Automatically sign the first <auto_sign_csr_amount> CSRs.
As certificate gets unconditionally emitted and only vital attributes
and extensions are forced during signature, you should choose the
smallest amount possible to get a functional service.
For a typical HTTP(S) caucase service, 1 should be enough for CAS usage
(first service certificate being to serve HTTPS for caucase), and 1 for
CAU usage (first user, which can then sign more user certificate
requests).
To verify nothing accessed the service before intended automated
requests, check issued certificate has an extension with OID:
2.25.285541874270823339875695650038637483517.0
(a message is printed when retrieving the certificate)
This mark is propagated during certificate renewal.
lock_auto_sign_csr_amount (bool)
When given with a true value, auto_sign_csr_amount is stored and the
value given on later instanciation will be ignored.
"""
cert = self._ca_key_pairs_list[-1]['crt']
expire_date = datetime.strptime(cert.get_notAfter(), '%Y%m%d%H%M%SZ')
renew_date = expire_date - timedelta(0, self.ca_renew_time)
if renew_date > datetime.now():
# The ca certificat should not be renewed now
return False
self.createCAKeyPair()
return True
self._storage = storage
if lock_auto_sign_csr_amount:
storage.setConfigOnce(
_CONFIG_NAME_AUTO_SIGN_CSR_AMOUNT,
auto_sign_csr_amount,
)
self._auto_sign_csr_amount = int(storage.getConfigOnce(
_CONFIG_NAME_AUTO_SIGN_CSR_AMOUNT,
auto_sign_csr_amount,
))
self._ca_key_size = ca_key_size
self._digest_list = digest_list
self._default_digest_class = getattr(hashes, self.digest_list[0].upper())
self._crt_life_time = datetime.timedelta(crt_life_time, 0)
self._crl_base_url = crl_base_url
self._ca_subject = x509.Name([
x509.NameAttribute(
oid=_SUBJECT_OID_DICT[key],
value=value,
)
for key, value in dict(ca_subject_dict).iteritems()
])
if ca_life_period < 3:
raise ValueError("ca_life_period must be >= 3 to allow CA rollout")
self._crl_life_time = datetime.timedelta(crt_life_time * crl_renew_period, 0)
self._ca_life_time = datetime.timedelta(crt_life_time * ca_life_period, 0)
self._loadCAKeyPairList()
self._renewCAIfNeeded()
@property
def digest_list(self):
"""
Read-only access to digest_list ctor parameter.
"""
return list(self._digest_list)
def _loadCAKeyPairList(self):
ca_key_pair_list = []
for pem_key_pair in self._storage.getCAKeyPairList():
utils.validateCertAndKey(pem_key_pair['crt_pem'], pem_key_pair['key_pem'])
ca_key_pair_list.append({
'crt': utils.load_ca_certificate(pem_key_pair['crt_pem']),
'key': utils.load_privatekey(pem_key_pair['key_pem']),
})
self._ca_key_pairs_list = ca_key_pair_list
def createCAKeyPair(self):
"""
Create a new ca key + certificate pair
"""
key_pair = {}
key = crypto.PKey()
# Use 2048 bits key size
key.generate_key(crypto.TYPE_RSA, 2048)
key_pair['key'] = key
ca = crypto.X509()
# 3 = v3
ca.set_version(3)
ca.set_serial_number(int(time.time()))
subject = ca.get_subject()
for name, value in self.ca_subject_dict.items():
setattr(subject, name, value)
ca.gmtime_adj_notBefore(0)
ca.gmtime_adj_notAfter(self.ca_life_time)
ca.set_issuer(ca.get_subject())
ca.set_pubkey(key)
self.extension_manager.setCaExtensions(ca)
ca.sign(key, self.default_digest)
key_pair['crt'] = ca
self._storage.storeCAKeyPair(key_pair)
self._ca_key_pairs_list = self._storage.getCAKeyPairList()
Create a new CA key pair.
CA certificate renewal normally happens automatically as long as
certificates are getting signed and revocation list downloaded.
"""
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=self._ca_key_size,
backend=_cryptography_backend,
)
public_key = private_key.public_key()
subject_key_identifier = x509.SubjectKeyIdentifier.from_public_key(
public_key,
)
now = datetime.datetime.utcnow()
certificate = x509.CertificateBuilder(
subject_name=self._ca_subject,
issuer_name=self._ca_subject,
not_valid_before=now,
not_valid_after=now + self._ca_life_time,
serial_number=x509.random_serial_number(),
public_key=public_key,
extensions=[
Extension(
x509.BasicConstraints(
ca=True,
path_length=0,
),
critical=True, # "MUST mark the extension as critical"
),
Extension(
x509.KeyUsage(
# pylint: disable=bad-whitespace
digital_signature =False,
content_commitment=False,
key_encipherment =False,
data_encipherment =False,
key_agreement =False,
key_cert_sign =True,
crl_sign =True,
encipher_only =False,
decipher_only =False,
# pylint: enable=bad-whitespace
),
critical=True, # "SHOULD mark this extension critical"
),
# Should we make use of certificate policies ? If we do, we need to enable
# this extension and fill the values.
# Extension(
# x509.PolicyConstraints(
# require_explicit_policy=,
# inhibit_policy_mapping=,
# ),
# critical=True, # MUST mark this extension as critical
# ),
Extension(
subject_key_identifier,
critical=False, # "MUST mark this extension as non-critical"
),
Extension(
x509.AuthorityKeyIdentifier.from_issuer_subject_key_identifier(
# Dummy extension, from_issuer_subject_key_identifier accesses .data directly
Extension(
subject_key_identifier,
critical=False,
),
),
critical=False, # "MUST mark this extension as non-critical"
),
],
).sign(
private_key=private_key,
algorithm=self._default_digest_class(),
backend=_cryptography_backend,
)
self._storage.appendCAKeyPair(
utils.datetime2timestamp(certificate.not_valid_after),
{
'key_pem': utils.dump_privatekey(private_key),
'crt_pem': utils.dump_certificate(certificate),
},
)
self._loadCAKeyPairList()
assert self._ca_key_pairs_list
def getPendingCertificateRequest(self, csr_id):
"""
Retrieve the content of a pending signing request.
@param csr_id: The id of CSR returned by the storage
def getCertificateSigningRequest(self, csr_id):
"""
return self._storage.getPendingCertificateRequest(csr_id)
Retrieve a PEM-encoded certificate signing request.
def createCertificateSigningRequest(self, csr):
"""
Sanity-check CSR, stores it and generates a unique signing request
identifier (crt_id).
@param csr: CSR string in PEM format
csr_id (int)
As returned when the CSR was stored.
"""
# Check number of already-pending signing requests
# Check if csr is self-signed
# Check it has a CN (?)
# Check its extensions
# more ?
try:
csr_pem = crypto.load_certificate_request(crypto.FILETYPE_PEM, csr)
except crypto.Error, e:
raise BadCertificateSigningRequest(str(e))
if not hasattr(csr_pem.get_subject(), 'CN') or not csr_pem.get_subject().CN:
raise BadCertificateSigningRequest("CSR has no common name set")
return self._storage.getCertificateSigningRequest(csr_id)
# XXX check extensions
def appendCertificateSigningRequest(self, csr_pem, override_limits=False):
"""
Store certificate signing request and return its identifier.
May trigger its signature if the quantity of submitted CSRs is less than
auto_sign_csr_amount (see __init__).
csr_id = self._storage.storeCertificateSigningRequest(csr_pem)
if self._storage.getCertificateSigningRequestAmount() <= \
self.auto_sign_csr_amount:
csr_pem (str)
PEM-encoded certificate signing request.
"""
csr = utils.load_certificate_request(csr_pem)
# Note: requested_amount is None when a known CSR is re-submitted
csr_id, requested_amount = self._storage.appendCertificateSigningRequest(
csr_pem=csr_pem,
key_id=x509.SubjectKeyIdentifier.from_public_key(
csr.public_key(),
).digest.encode('hex'),
override_limits=override_limits,
)
if requested_amount is not None and \
requested_amount <= self._auto_sign_csr_amount:
# if allowed to sign this certificate automaticaly
self.createCertificate(csr_id)
self._createCertificate(csr_id, auto_signed=_AUTO_SIGNED_YES)
return csr_id
def deletePendingCertificateRequest(self, csr_id):
def deletePendingCertificateSigningRequest(self, csr_id):
"""
Reject a pending certificate signing request.
@param csr_id: The id of CSR returned by the storage
"""
self._storage.deletePendingCertificateRequest(csr_id)
def getPendingCertificateRequestList(self, limit=0, with_data=False):
"""
Return list of pending certificate signature request
@param limit: number of element to fetch, 0 is not limit (int)
@param with_data: True or False, say if return csr PEM string associated
to others informations (bool).
"""
return self._storage.getPendingCertificateRequestList(limit, with_data)
def createCertificate(self, csr_id, ca_key_pair=None, subject_dict=None):
"""
Generate new signed certificate. `ca_key_pair` is the CA key_pair to use
if None, use the latest CA key_pair
@param csr_id: CSR ID returned by storage, csr should be linked to the
new certificate (string).
@param ca_key_pair: The CA key_pair to used for signature. If None, the
latest key_pair is used.
@param subject_dict: dict of subject attributes to use in x509 subject,
if None, csr subject is used (dict).
"""
# Apply extensions (ex: "not a certificate", ...)
# Generate a certificate from the CSR
# Sign the certificate with the current CA key
csr_pem = crypto.load_certificate_request(crypto.FILETYPE_PEM,
self._storage.getPendingCertificateRequest(csr_id))
# Certificate serial is the csr_id without extension .csr.pem
serial = int(csr_id[:-8], 16)
subject = None
if ca_key_pair is None:
ca_key_pair = self._ca_key_pairs_list[-1]
if subject_dict:
if subject_dict.has_key('C') and len(subject_dict['C']) != 2:
# Country code size is 2
raise ValueError("Country Code size in subject should be equal to 2.")
if not subject_dict.has_key('CN'):
raise AttributeError("Attribute 'CN' is required in subject.")
try:
subject = getX509NameFromDict(**subject_dict)
except AttributeError:
raise AttributeError("X509Name attribute not found. Subject " \
"keys should be in %r" % SUBJECT_KEY_LIST)
cert_pem = self._generateCertificateObjects(ca_key_pair,
csr_pem,
serial,
subject=subject)
crt_id = self._storage.storeCertificate(csr_id, cert_pem)
return crt_id
def getCertificate(self, crt_id):
"""
Return a Certificate string in PEM format
@param crt_id: Certificate ID returned by storage during certificate creation
"""
return self._storage.getCertificate(crt_id)
csr_id (int)
CSR id, as returned when the CSR was stored.
"""
self._storage.deletePendingCertificateSigningRequest(csr_id)
def getCertificateRequestList(self):
"""
Return the list of pending certificate signature requests, individually
PEM-encoded.
"""
return self._storage.getCertificateSigningRequestList()
def createCertificate(self, csr_id, template_csr=None):
"""
Sign a pending certificate signing request, storing produced certificate.
csr_id (int)
CSR id, as returned when the CSR was stored.
template_csr (None or X509Req)
Copy extensions and subject from this CSR instead of stored one.
Useful to renew a certificate.
Public key is always copied from stored CSR.
"""
self._createCertificate(
csr_id=csr_id,
auto_signed=_AUTO_SIGNED_NO,
template_csr=template_csr,
)
def _createCertificate(self, csr_id, auto_signed, template_csr=None):
"""
auto_signed (bool)
When True, mark certificate as having been auto-signed.
When False, prevent such mark from being set.
When None, do not filter (useful when renewing).
tempate_csr (None or X509Req)
Copy extensions and subject from this CSR instead of stored one.
Useful to renew a certificate.
Public key is always copied from stored CSR.
"""
csr_pem = self._storage.getCertificateSigningRequest(csr_id)
csr = utils.load_certificate_request(csr_pem)
if template_csr is None:
template_csr = csr
ca_key_pair = self._getCurrentCAKeypair()
ca_crt = ca_key_pair['crt']
public_key = csr.public_key()
subject_key_identifier = x509.SubjectKeyIdentifier.from_public_key(
public_key,
)
now = datetime.datetime.utcnow()
builder = x509.CertificateBuilder(
subject_name=template_csr.subject,
issuer_name=ca_crt.subject,
not_valid_before=now,
not_valid_after=now + self._crt_life_time,
serial_number=x509.random_serial_number(),
public_key=public_key,
extensions=[
Extension(
x509.BasicConstraints(
ca=False,
path_length=None,
),
critical=True, # "MAY appear as critical or non-critical"
),
Extension(
subject_key_identifier,
critical=False, # "MUST mark this extension as non-critical"
),
Extension(
x509.AuthorityKeyIdentifier.from_issuer_subject_key_identifier(
ca_crt.extensions.get_extension_for_class(x509.SubjectKeyIdentifier),
),
critical=False, # "MUST mark this extension as non-critical"
),
],
)
# Note: disabled because of following IPv6 bug:
# https://github.com/pyca/cryptography/issues/3863
# if self._crl_base_url:
# builder = builder.add_extension(
# x509.CRLDistributionPoints([
# x509.DistributionPoint(
# full_name=[
# x509.UniformResourceIdentifier(self._crl_base_url),
# ],
# relative_name=None,
# crl_issuer=None,
# reasons=None,
# ),
# ]),
# critical=False, # "SHOULD be non-critical"
# )
try:
key_usage_extension = template_csr.extensions.get_extension_for_class(
x509.KeyUsage,
)
except x509.ExtensionNotFound:
pass
else:
key_usage = key_usage_extension.value
if key_usage.key_agreement:
encipher_only = key_usage.encipher_only
decipher_only = key_usage.decipher_only
else:
encipher_only = decipher_only = False
builder = builder.add_extension(
x509.KeyUsage(
# pylint: disable=bad-whitespace
digital_signature =key_usage.digital_signature,
content_commitment=key_usage.content_commitment,
key_encipherment =key_usage.key_encipherment,
data_encipherment =key_usage.data_encipherment,
key_agreement =key_usage.key_agreement,
key_cert_sign =False,
crl_sign =False,
encipher_only =encipher_only,
decipher_only =decipher_only,
# pylint: enable=bad-whitespace
),
critical=key_usage_extension.critical, # "SHOULD mark this extension critical"
)
try:
extended_key_usage = template_csr.extensions.get_extension_for_class(
x509.ExtendedKeyUsage,
)
except x509.ExtensionNotFound:
pass
else:
builder = builder.add_extension(
x509.ExtendedKeyUsage(
[
x for x in extended_key_usage.value
if x != x509.oid.ExtendedKeyUsageOID.OCSP_SIGNING
]
),
critical=extended_key_usage.critical,
)
try:
subject_alt_name = template_csr.extensions.get_extension_for_class(
x509.SubjectAlternativeName,
)
except x509.ExtensionNotFound:
pass
else:
# Note: as issued certificates may be used without any subject
# validation (ex: connecting to mariadb via a variable IP), we
# voluntarily do not enforce any constraint on subjectAltName.
builder = builder.add_extension(
subject_alt_name.value,
critical=subject_alt_name.critical,
)
# subjectDirectoryAttributes ?
try:
certificate_policies = template_csr.extensions.get_extension_for_class(
x509.CertificatePolicies,
)
except x509.ExtensionNotFound:
if auto_signed == _AUTO_SIGNED_YES:
builder = builder.add_extension(
x509.CertificatePolicies([
utils.CAUCASE_POLICY_INFORMATION_AUTO_SIGNED,
]),
critical=False, # (no recommendations)
)
else:
if auto_signed == _AUTO_SIGNED_PASSTHROUGH:
# Caller is asking us to let all through, so do this.
policy_list = certificate_policies.value
else:
# Prevent any caucase extension from being smuggled, especiall the
# "auto-signed" one...
policy_list = [
x for x in certificate_policies.value
if not x.policy_identifier.dotted_string.startswith(utils.CAUCASE_OID_TOP)
]
if auto_signed == _AUTO_SIGNED_YES:
# ...but do add auto-signed extension if we are auto-signing.
policy_list.append(utils.CAUCASE_POLICY_INFORMATION_AUTO_SIGNED)
builder = builder.add_extension(
x509.CertificatePolicies(policy_list),
critical=certificate_policies.critical, # (no recommendations)
)
cert_pem = utils.dump_certificate(builder.sign(
private_key=ca_key_pair['key'],
algorithm=self._default_digest_class(),
backend=_cryptography_backend,
))
self._storage.storeCertificate(csr_id, cert_pem)
return cert_pem
def getCertificate(self, csr_id):
"""
Return PEM-encoded signed certificate.
csr_id (int)
As returned when the corresponding CSR was stored.
"""
return self._storage.getCertificate(csr_id)
def _renewCAIfNeeded(self):
"""
Create a new CA certificate if latest one has less than two
ca_life_periods of validity left.
Updates self._ca_key_pairs_list .
"""
if not self._ca_key_pairs_list or (
self._ca_key_pairs_list[-1]['crt'].not_valid_after - datetime.datetime.utcnow()
).total_seconds() / self._crt_life_time.total_seconds() <= 2:
# No CA certificate at all or less than 2 certificate validity periods
# left with latest CA certificate. Prepare the next one so it starts
# getting distributed.
self.createCAKeyPair()
def getCertificateFromSerial(self, serial):
"""
Return a Certificate string in PEM format
@param serial: serial of the certificate (string)
"""
cert = self._storage.getCertificateFromSerial(serial)
if not cert.content:
raise NotFound('Content certificate with serial %r is not found.' % (
serial,
))
return cert.content
def _getCurrentCAKeypair(self):
"""
Return the currently-active CA certificate key pair.
Currently-active CA certificate is the CA to use when signing. It may not
be the latest one, as all certificate holders must know the latest one
before its use can start.
"""
self._renewCAIfNeeded()
now = datetime.datetime.utcnow()
for key_pair in reversed(self._ca_key_pairs_list):
if key_pair['crt'].not_valid_before + self._crt_life_time < now:
# This CA cert is valid for more than one certificate life time,
# we can assume clients to know it (as they had to renew their
# cert at least once since it became available) so we can start
# using it.
break
else:
# No CA cert is valid for more than one certificate life time, so just pick
# the newest one.
key_pair = self._ca_key_pairs_list[-1]
return key_pair
def getSignedCertificateList(self, limit=0, with_data=False):
def getCACertificate(self):
"""
Return list of signed certificate
@param limit: number of element to fetch, 0 is not limit (int)
@param with_data: True or False, say if return cert PEM string associated
to others informations (bool).
Return current CA certificate, PEM-encoded.
"""
return self._storage.getSignedCertificateList(limit, with_data)
return utils.dump_certificate(self._getCurrentCAKeypair()['crt'])
def getCACertificate(self):
def getCACertificateList(self):
"""
Return current CA certificate
Return the current list of CA certificates as X509 obbjects.
"""
return self._dumpCertificate(self._ca_key_pairs_list[-1]['crt'])
self._renewCAIfNeeded()
return [x['crt'] for x in self._ca_key_pairs_list]
def getValidCACertificateChain(self):
"""
Return the ca certificate chain for all valid certificates with key
"""
result = []
iter_key_pair = iter(self._ca_key_pairs_list)
previous_key_pair = iter_key_pair.next()
for key_pair in iter_key_pair:
result.append(utils.wrap({
'old': self._dumpCertificate(previous_key_pair['crt']),
'new': self._dumpCertificate(key_pair.crt),
}, self._dumpPrivatekey(previous_key_pair['key']), self.digest_list))
return result
Return the CA certificate chain based on oldest CA certificate.
def getCAKeypairForCertificate(self, cert):
"""
Return the nearest CA key_pair to the next extension date of the cert
@param cert: X509 certificate
"""
cert_valid_date = datetime.strptime(cert.get_notAfter(), '%Y%m%d%H%M%SZ')
next_valid_date = datetime.utcnow() + timedelta(0, self.crt_life_time)
# check which ca certificate should be used to renew the cert
selected_keypair = None
selected_date = None
for key_pair in self._ca_key_pairs_list:
expiration_date = datetime.strptime(key_pair['crt'].get_notAfter(), '%Y%m%d%H%M%SZ')
if expiration_date < next_valid_date:
continue
if selected_date and selected_date < expiration_date:
# Only get the lowest expiration_date which cover the renew notbefore date
continue
selected_keypair = key_pair
selected_date = expiration_date
Each item in the chain is a wrapped dict with the following keys:
old (str)
N-1 certificate as PEM, used to check wrapper signature.
If item is the first in the chain, this is the oldest CA certificate
server still knows about.
new (str)
N certificate as PEM.
if selected_keypair is None:
raise ValueError("No valid CA key_pair found with validity date upper than %r certificate lifetime" %
next_valid_date)
The intent is for a client knowing one CA certificate to retrieve any newer
CA certificate and autonomously decide if it may trust them: each item is
signed with the previous certificate. The oldest CA certificate is not
returned in this list, as it cannot be signed by another one.
return selected_keypair
CA user must check that there is an uninterrupted signed path from its
already-known CA certificate to use any contained "new" certificate.
It must skip any certificate pair for which it does not already trust
an ancestor certificate.
def revokeCertificate(self, wrapped_crt):
Note: the chain may contain expired CA certificates. CA user should skip
these, and consider their signature invalid for CA chain validation
purposes.
"""
Revoke a certificate
@param wrapped_crt: The revoke request dict containing certificate to
revoke and signature algorithm used to sign the request.
{
"signature": "signature string for payload",
"digest": "Signature algorithm (ex: SHA256"),
"payload": dict of data: {
"revoke_crt": "Certificate to revoke",
"reason": "Revoke reason"
}
}
"""
payload = utils.unwrap(wrapped_crt, lambda x: x['revoke_crt'], self.digest_list)
try:
x509 = self._loadCertificate(payload['revoke_crt'])
except crypto.Error, e:
raise BadCertificate(str(e))
if not utils.verifyCertificateChain(x509,
[x['crt'] for x in self._ca_key_pairs_list]):
raise CertificateVerificationError("Certificate verification failed:" \
"The CA couldn't reconize the certificate to revoke.")
crt = self._loadCertificate(payload['revoke_crt'])
reason = payload['reason']
return self._storage.revokeCertificate(
utils.getSerialToInt(crt),
reason)
def revokeCertificateFromID(self, crt_id):
"""
Directly revoke a certificate from crt_id
@param crt_id: The ID of the certificate (string)
"""
return self._storage.revokeCertificate(
crt_id=crt_id,
reason="")
def renew(self, wrapped_csr):
"""
Renew a certificate
@param wrapped_csr: The revoke request dict containing certificate to
revoke and signature algorithm used to sign the request.
self._renewCAIfNeeded()
result = []
iter_key_pair = iter(self._ca_key_pairs_list)
first_key_pair = iter_key_pair.next()
previous_crt_pem = utils.dump_certificate(first_key_pair['crt'])
previous_key = first_key_pair['key']
for key_pair in iter_key_pair:
current_crt_pem = utils.dump_certificate(key_pair['crt'])
result.append(utils.wrap(
{
"signature": "signature string for payload",
"digest": "Signature algorithm (ex: SHA256"),
"payload": dict of data: {
"crt": "Old certificate to renew",
"renew_csr": "New CSR to sign"
}
}
"""
payload = utils.unwrap(wrapped_csr, lambda x: x['crt'], self.digest_list)
csr = payload['renew_csr']
try:
x509 = self._loadCertificate(payload['crt'])
except crypto.Error, e:
raise BadCertificate(str(e))
'old_pem': previous_crt_pem,
'new_pem': current_crt_pem,
},
previous_key,
self.digest_list[0],
))
previous_key = key_pair['key']
previous_crt_pem = current_crt_pem
return result
try:
csr_pem = crypto.load_certificate_request(crypto.FILETYPE_PEM, csr)
except crypto.Error, e:
raise BadCertificateSigningRequest(str(e))
if csr_pem.get_subject().CN != x509.get_subject().CN:
raise BadCertificateSigningRequest(
"Request common name does not match replaced certificate.")
if not self._storage.getCertificateFromSerial(utils.getSerialToInt(x509)):
raise NotFound('No Certificate with serial %r and Common Name %r found.' % (
x509.get_serial_number(),
x509.get_subject().CN,
))
if not utils.verifyCertificateChain(x509,
[x['crt'] for x in self._ca_key_pairs_list]):
raise CertificateVerificationError("Certificate verification failed:" \
"The CA couldn't reconize signed certificate.")
csr_id = self.createCertificateSigningRequest(csr)
# sign the new certificate using a specific ca key_pair
ca_key_pair = self.getCAKeypairForCertificate(x509)
self.createCertificate(csr_id, ca_key_pair)
return csr_id
def revoke(self, crt_pem):
"""
Revoke certificate.
crt_pem (str)
PEM-encoded certificat to revoke.
"""
crt = utils.load_certificate(
crt_pem,
self.getCACertificateList(),
x509.load_pem_x509_crl(
self.getCertificateRevocationList(),
_cryptography_backend,
),
)
self._storage.revoke(
serial=crt.serial_number,
expiration_date=utils.datetime2timestamp(crt.not_valid_after),
)
def revokeSerial(self, serial):
"""
Revoke a certificate by its serial only.
Revocation will expire when the latest CA certificate of this instance
expires, meaning it will stay longer in the revocation list than when
certificate expiration date can be retrieved from the certificate.
Also, there cannot be any check on the validity of the serial, typos
are accepted verbatim.
Using this method is hence not recomended.
"""
self._storage.revoke(
serial=serial,
expiration_date=utils.datetime2timestamp(max(
x.not_valid_after for x in self.getCACertificateList()
)),
)
def renew(self, crt_pem, csr_pem):
"""
Renew certificate.
crt_pem (str)
PEM-encoded certificate to renew.
csr_pem (str)
PEM-encoded certificate signing request.
"""
ca_cert_list = self.getCACertificateList()
crt = utils.load_certificate(
crt_pem,
ca_cert_list,
x509.load_pem_x509_crl(
self.getCertificateRevocationList(),
_cryptography_backend,
),
)
return self._createCertificate(
csr_id=self.appendCertificateSigningRequest(csr_pem),
auto_signed=_AUTO_SIGNED_PASSTHROUGH,
# Do a dummy signature, just so we get a usable
# x509.CertificateSigningRequest instance. Use latest CA private key just
# because it is available for free (unlike generating a new one).
template_csr=x509.CertificateSigningRequestBuilder(
subject_name=crt.subject,
extensions=crt.extensions,
).sign(
private_key=self._ca_key_pairs_list[-1]['key'],
algorithm=self._default_digest_class(),
backend=_cryptography_backend,
),
)
def getCertificateRevocationList(self):
"""
Generate certificate revocation list PEM
"""
crl = self._storage.getCertificateRevocationList()
if not crl:
# Certificate revocation list needs to be regenerated
return self._createCertificateRevocationList()
return crl
def _loadCertificate(self, cert_string):
"""
Load certificate in PEM format
"""
return crypto.load_certificate(crypto.FILETYPE_PEM, cert_string)
def _dumpCertificate(self, cert_object):
"""
Dump certificate in PEM format
"""
return crypto.dump_certificate(crypto.FILETYPE_PEM, cert_object)
def _loadPrivatekey(self, pkey):
"""
Load private key in PEM format
"""
return crypto.load_privatekey(crypto.FILETYPE_PEM, pkey)
def _dumpPrivatekey(self, pkey_object):
"""
Load private key in PEM format
"""
return crypto.dump_privatekey(crypto.FILETYPE_PEM, pkey_object)
def _generateCertificateObjects(self, ca_key_pair, req, serial, subject=None):
"""
Generate certificate from CSR PEM Object.
This method set default certificate extensions, later will allow to set custom extensions
ca_key_pair: ca_key_pair which should be used to sign certificate
req: csr object to sign
serial: serial to apply to the new signed certificate
subject: give a dict containing new subject to apply on signed certificate
if subject is None, req.get_subject() is used.
"""
if subject is None:
subject = req.get_subject()
# Here comes the actual certificate
cert = crypto.X509()
# version v3
cert.set_version(2)
cert.set_serial_number(serial)
cert.gmtime_adj_notBefore(0)
cert.gmtime_adj_notAfter(self.crt_life_time)
cert.set_issuer(ca_key_pair['crt'].get_subject())
cert.set_subject(subject)
cert.set_pubkey(req.get_pubkey())
self.extension_manager.setDefaultExtensions(
cert,
subject=cert,
issuer=ca_key_pair['crt'],
crl_url=self.crl_base_url)
cert.sign(ca_key_pair['key'], self.default_digest)
return cert
def _createCertificateRevocationList(self):
"""
Create CRL from certification revocation_list and return a PEM string content
"""
revocation_list = self._storage.getRevocationList()
now = datetime.utcnow()
crl = crypto.CRL()
# XXX - set_nextUpdate() doesn't update Next Update in generated CRL,
# So we have used export() which takes the number of days in param
#
# next_date = now + timedelta(0, 864000) #self.crl_life_time)
# crl.set_lastUpdate(now.strftime("%Y%m%d%H%M%SZ").encode("ascii"))
# crl.set_nextUpdate(next_date.strftime("%Y%m%d%H%M%SZ").encode("ascii"))
num_crl_days = int(round(self.crl_life_time/(24.0*60*60), 0))
if num_crl_days == 0:
# At least one day
num_crl_days = 1
Return PEM-encoded certificate revocation list.
"""
crl_pem = self._storage.getCertificateRevocationList()
if crl_pem is None:
ca_key_pair = self._getCurrentCAKeypair()
now = datetime.datetime.utcnow()
crl = x509.CertificateRevocationListBuilder(
issuer_name=ca_key_pair['crt'].issuer,
last_update=now,
next_update=now + self._crl_life_time,
extensions=[
Extension(
x509.CRLNumber(
self._storage.getNextCertificateRevocationListNumber(),
),
critical=False, # "MUST mark this extension as non-critical"
),
],
revoked_certificates=[
x509.RevokedCertificateBuilder(
serial_number=x['serial'],
revocation_date=datetime.datetime.fromtimestamp(
x['revocation_date'],
),
).build(_cryptography_backend)
for x in self._storage.getRevocationList()
],
).sign(
private_key=ca_key_pair['key'],
algorithm=self._default_digest_class(),
backend=_cryptography_backend,
)
crl_pem = crl.public_bytes(serialization.Encoding.PEM)
self._storage.storeCertificateRevocationList(
crl_pem,
expiration_date=utils.datetime2timestamp(crl.next_update),
)
return crl_pem
class UserCertificateAuthority(CertificateAuthority):
"""
Backup-able CertificateAuthority.
for revocation in revocation_list:
revoked = crypto.Revoked()
revoked.set_rev_date(
revocation.creation_date.strftime("%Y%m%d%H%M%SZ").encode("ascii")
)
revoked.set_serial(revocation.serial.encode("ascii"))
revoked.set_reason(None) #b'%s' % revocation.reason)
crl.add_revoked(revoked)
version_number = self._storage.getNextCRLVersionNumber()
crl.set_version(version_number)
# XXX - set how to get the cacert here
cert = self._ca_key_pairs_list[-1]['crt']
key = self._ca_key_pairs_list[-1]['key']
#crl.sign(cert, key, self.default_digest)
dumped_crl = crl.export(
cert,
key,
type=crypto.FILETYPE_PEM,
days=num_crl_days,
digest=self.default_digest)
return self._storage.storeCertificateRevocationList(
crypto.load_crl(crypto.FILETYPE_PEM, dumped_crl),
expiration_date=(now + timedelta(num_crl_days, 0))
)
See backup schema in documentation.
"""
def doBackup(self, write):
"""
Backup the entire storage to given path, enciphering it using all stored
certificates.
"""
ca_cert_list = self.getCACertificateList()
crl = x509.load_pem_x509_crl(
self.getCertificateRevocationList(),
_cryptography_backend,
)
signing_key = os.urandom(32)
symetric_key = os.urandom(32)
iv = os.urandom(16)
encryptor = Cipher(
algorithms.AES(symetric_key),
modes.CBC(iv),
backend=_cryptography_backend,
).encryptor()
authenticator = hmac.HMAC(
signing_key,
hashes.SHA256(),
backend=_cryptography_backend,
)
HMAC_PAYLOAD_SIZE = 10 * 1024 * 1024
key_list = []
for crt_pem in self._storage.iterCertificates():
try:
crt = utils.load_certificate(crt_pem, ca_cert_list, crl)
except CertificateVerificationError:
continue
public_key = crt.public_key()
key_list.append({
'id': x509.SubjectKeyIdentifier.from_public_key(
public_key,
).digest.encode('hex'),
'cipher': {
'name': 'rsa_oaep_sha1_mgf1_sha1',
},
'key': public_key.encrypt(
signing_key + symetric_key,
OAEP(
mgf=MGF1(algorithm=hashes.SHA1()),
algorithm=hashes.SHA1(),
label=None,
),
).encode('hex'),
})
if not key_list:
# No users yet, backup is meaningless
return False
header = json.dumps({
'cipher': {
'name': 'aes256_cbc_pkcs7_hmac_10M_sha256',
'parameter': iv.encode('hex'),
},
'key_list': key_list,
})
padder = padding.PKCS7(128).padder()
write(_BACKUP_MAGIC)
write(struct.pack('<I', len(header)))
write(header)
def signingIterator():
"""
Iterate over cleartext dump, inserting HMAC between each chunk.
"""
buf = b''
for chunk in self._storage.dumpIterator():
buf += chunk
while len(buf) >= HMAC_PAYLOAD_SIZE:
chunk = buf[:HMAC_PAYLOAD_SIZE]
buf = buf[HMAC_PAYLOAD_SIZE:]
authenticator.update(chunk)
yield chunk
yield authenticator.copy().finalize()
if buf:
authenticator.update(buf)
yield buf
yield authenticator.finalize()
for chunk in signingIterator():
write(encryptor.update(padder.update(chunk)))
write(encryptor.update(padder.finalize()))
write(encryptor.finalize())
return True
@classmethod
def restoreBackup(
cls,
db_class,
db_path,
read,
key_pem,
csr_pem,
db_kw=(),
kw=(),
):
"""
Restore backup, revoke certificate corresponding to private key and sign
its renewal.
"""
magic = read(8)
if magic != _BACKUP_MAGIC:
raise ValueError('Invalid backup magic string')
header_len, = struct.unpack(
'<I',
read(struct.calcsize('<I')),
)
header = json.loads(read(header_len))
if header['cipher']['name'] != 'aes256_cbc_pkcs7_hmac_10M_sha256':
raise ValueError('Unrecognised symetric cipher')
private_key = utils.load_privatekey(key_pem)
key_id = x509.SubjectKeyIdentifier.from_public_key(
private_key.public_key(),
).digest.encode('hex')
symetric_key_list = [
x for x in header['key_list'] if x['id'] == key_id
]
if not symetric_key_list:
raise ValueError(
'Given private key is not a good candidate for restoring this backup',
)
symetric_key_entry, = symetric_key_list
if symetric_key_entry['cipher']['name'] != 'rsa_oaep_sha1_mgf1_sha1':
raise ValueError('Unrecognised asymetric cipher')
both_keys = private_key.decrypt(
symetric_key_entry['key'].decode('hex'),
OAEP(
mgf=MGF1(algorithm=hashes.SHA1()),
algorithm=hashes.SHA1(),
label=None,
),
)
if len(both_keys) != 64:
raise ValueError('Invalid key length')
decryptor = Cipher(
algorithms.AES(both_keys[32:]),
modes.CBC(header['cipher']['parameter'].decode('hex')),
backend=_cryptography_backend,
).decryptor()
unpadder = padding.PKCS7(128).unpadder()
authenticator = hmac.HMAC(
both_keys[:32],
hashes.SHA256(),
backend=_cryptography_backend,
)
HMAC_PAYLOAD_SIZE = 10 * 1024 * 1024
# Each block has its signature
HMAC_SIGNED_SIZE = HMAC_PAYLOAD_SIZE + 32
CHUNK_SIZE = HMAC_SIGNED_SIZE
def restorator():
"""
Iterate over backup payload, decyphering by small chunks.
"""
while True:
chunk = read(CHUNK_SIZE)
if chunk:
yield unpadder.update(decryptor.update(chunk))
else:
yield unpadder.update(decryptor.finalize()) + unpadder.finalize()
break
def verificator():
"""
Iterate over decrypted payload, verifying HMAC on each chunk.
"""
buf = b''
for clear in restorator():
buf += clear
while len(buf) >= HMAC_SIGNED_SIZE:
signed = buf[:HMAC_SIGNED_SIZE]
buf = buf[HMAC_SIGNED_SIZE:]
chunk = signed[:-32]
authenticator.update(chunk)
authenticator.copy().verify(signed[-32:])
yield chunk
if buf:
chunk = buf[:-32]
authenticator.update(chunk)
authenticator.verify(buf[-32:])
yield chunk
db_class.restore(db_path=db_path, restorator=verificator())
# Now that the database is restored, use a CertificateAuthority to
# renew & revoke given private key.
self = cls(storage=db_class(db_path=db_path, **dict(db_kw)), **dict(kw))
# pylint: disable=protected-access
crt_pem = self._storage.getCertificateByKeyIdentifier(key_id)
# pylint: enable=protected-access
new_crt_pem = self.renew(crt_pem, csr_pem)
self.revoke(crt_pem)
return new_crt_pem
......@@ -15,33 +15,862 @@
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
"""
Caucase - Certificate Authority for Users, Certificate Authority for SErvices
"""
from __future__ import absolute_import
import argparse
import datetime
import httplib
import json
import os
from caucase import app, db
from flask_alchemydumps import AlchemyDumps, AlchemyDumpsCommand
from flask_script import Manager, Command
import struct
import sys
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from . import utils
from . import exceptions
from .client import (
CaucaseError,
CaucaseClient,
HTTPSOnlyCaucaseClient,
updateCAFile,
updateCRLFile,
)
_cryptography_backend = default_backend()
app.config.update(
DEBUG=False,
CSRF_ENABLED=True,
TESTING=False,
SQLALCHEMY_DATABASE_URI='sqlite:///%sca.db' % os.environ.get('CAUCASE_DIR', '')
)
STATUS_ERROR = 1
STATUS_WARNING = 2
STATUS_CALLBACK_ERROR = 3
MODE_SERVICE = 'service'
MODE_USER = 'user'
class CLICaucaseClient(object):
"""
CLI functionalities
"""
# Note: this class it more to reduce local variable scopes (avoiding
# accidental mixups) in each methods than about API declaration.
def __init__(self, client):
self._client = client
def putCSR(self, csr_path_list):
"""
--send-csr
"""
for csr_path in csr_path_list:
csr_pem = utils.getCertRequest(csr_path)
# Quick sanity check
utils.load_certificate_request(csr_pem)
print self._client.putCSR(csr_pem), csr_path
def getCSR(self, csr_id_path_list):
"""
--get-csr
"""
for csr_id, csr_path in csr_id_path_list:
csr_pem = self._client.getCSR(int(csr_id))
with open(csr_path, 'a') as csr_file:
csr_file.write(csr_pem)
manager = Manager(app)
def getCRT(self, warning, error, crt_id_path_list, ca_list):
"""
--get-crt
"""
for crt_id, crt_path in crt_id_path_list:
crt_id = int(crt_id)
try:
crt_pem = self._client.getCRT(crt_id)
except CaucaseError, e:
if e.args[0] != httplib.NOT_FOUND:
raise
try:
self._client.getCSR(crt_id)
except CaucaseError, e:
if e.args[0] != httplib.NOT_FOUND:
raise
print crt_id, 'not found - either csr id has a typo or CSR was rejected'
error = True
else:
print crt_id, 'CSR still pending'
warning = True
else:
print crt_id,
if utils.isCertificateAutoSigned(utils.load_certificate(
crt_pem,
ca_list,
None,
)):
print 'was (originally) automatically approved'
else:
print 'was (originally) manually approved'
if os.path.exists(crt_path):
try:
key_pem = utils.getKey(crt_path)
except ValueError:
print >>sys.stderr, (
'Expected to find exactly one privatekey key in %s, skipping' % (
crt_path,
)
)
error = True
continue
try:
utils.validateCertAndKey(crt_pem, key_pem)
except ValueError:
print >>sys.stderr, (
'Key in %s does not match retrieved certificate, skipping'
)
error = True
continue
with open(crt_path, 'a') as crt_file:
crt_file.write(crt_pem)
return warning, error
# init Alchemy Dumps
alchemydumps = AlchemyDumps(app, db)
manager.add_command('database', AlchemyDumpsCommand)
def revokeCRT(self, error, crt_key_list):
"""
--revoke-crt
"""
for crt_path, key_path in crt_key_list:
try:
crt, key, _ = utils.getKeyPair(crt_path, key_path)
except ValueError:
print >>sys.stderr, (
'Could not find (exactly) one matching key pair in %s, skipping' % (
[x for x in set((crt_path, key_path)) if x]
)
)
error = True
continue
self._client.revokeCRT(crt, key)
return error
@manager.command
def housekeep():
def renewCRT(
self,
crt_key_list,
renewal_deadline,
key_len,
ca_certificate_list,
updated,
error,
):
"""
--renew-crt
"""
for crt_path, key_path in crt_key_list:
try:
old_crt_pem, old_key_pem, key_path = utils.getKeyPair(
crt_path,
key_path,
)
except ValueError:
print >>sys.stderr, (
'Could not find (exactly) one matching key pair in %s, skipping' % (
[x for x in set((crt_path, key_path)) if x]
)
)
error = True
continue
try:
old_crt = utils.load_certificate(old_crt_pem, ca_certificate_list, None)
except exceptions.CertificateVerificationError:
print crt_path, (
'was not signed by this CA, revoked or otherwise invalid, skipping'
)
continue
if renewal_deadline < old_crt.not_valid_after:
print crt_path, 'did not reach renew threshold, not renewing'
continue
new_key_pem, new_crt_pem = self._client.renewCRT(
old_crt=old_crt,
old_key=utils.load_privatekey(old_key_pem),
key_len=key_len,
)
if key_path is None:
with open(crt_path, 'w') as crt_file:
crt_file.write(new_key_pem)
crt_file.write(new_crt_pem)
else:
with open(crt_path, 'w') as crt_file, open(key_path, 'w') as key_file:
key_file.write(new_key_pem)
crt_file.write(new_crt_pem)
updated = True
return updated, error
def listCSR(self, mode):
"""
--list-csr
"""
print '-- pending', mode, 'CSRs --'
print '%20s | %s' % (
'csr_id',
'subject preview (fetch csr and check full content !)',
)
for entry in self._client.getCSRList():
csr = utils.load_certificate_request(entry['csr'])
print '%20i | %r' % (
entry['id'],
csr.subject,
)
print '-- end of pending', mode, 'CSRs --'
def signCSR(self, csr_id_list):
"""
--sign-csr
"""
for csr_id in csr_id_list:
self._client.signCSR(int(csr_id))
def signCSRWith(self, csr_id_path_list):
"""
--sign-csr-with
"""
for csr_id, csr_path in csr_id_path_list:
self._client.signCSR(
int(csr_id),
template_csr=utils.getCertRequest(csr_path),
)
def rejectCSR(self, csr_id_list):
"""
--reject-csr
"""
for csr_id in csr_id_list:
self._client.deleteCSR(int(csr_id))
def revokeOtherCRT(self, crt_list):
"""
--revoke-other-crt
"""
error = False
for crt_path in crt_list:
try:
# Note: also raises when there are serveral certs. This is intended:
# revoking many certs from a single file seems a dubious use-case
# (especially in the automated issuance context, which is supposed to
# be caucase's main target), with high risk if carried without
# questions (too many certificates revoked, or asingle unexpected one
# among these, ...) and unambiguous solution is easy (if a human is
# involved, as is likely the case, more or less directly, for
# authenticated revocations).
crt_pem = utils.getCert(crt_path)
except ValueError:
print >>sys.stderr, (
'Could not load a single certificate in %s, skipping' % (
crt_path,
)
)
self._client.revokeCRT(crt_pem)
return error
def revokeSerial(self, serial_list):
"""
--revoke-serial
"""
for serial in serial_list:
self._client.revokeSerial(serial)
def main(argv=None):
"""
Start Storage housekeep method to cleanup garbages
Command line caucase client entry point.
"""
from caucase.storage import Storage
storage = Storage(db)
storage.housekeep()
parser = argparse.ArgumentParser(description='caucase')
# XXX: currently, it is the server which chooses which digest is used to sign stuff.
# Should clients be able to tell it how to sign (and server could reject) ?
parser.add_argument(
'--ca-url',
required=True,
metavar='URL',
help='caucase service HTTP base URL.',
)
parser.add_argument(
'--ca-crt',
default='cas.crt.pem',
metavar='CRT_PATH',
help='Services CA certificate file location. default: %(default)s',
)
parser.add_argument(
'--user-ca-crt',
default='cau.crt.pem',
metavar='CRT_PATH',
help='Users CA certificate file location. default: %(default)s',
)
parser.add_argument(
'--crl',
default='cas.crl.pem',
metavar='CRL_PATH',
help='Services certificate revocation list location. default: %(default)s',
)
parser.add_argument(
'--user-crl',
default='cau.crl.pem',
metavar='CRL_PATH',
help='Users certificate revocation list location. default: %(default)s',
)
parser.add_argument(
'--threshold',
default=31,
type=float,
help='The remaining certificate validity period, in days, under '
'which a renew is desired. default: %(default)s',
)
parser.add_argument(
'--key-len',
default=2048,
type=int,
metavar='BITLENGTH',
help='Number of bits to use when generating a new private key. '
'default: %(default)s',
)
parser.add_argument(
'--on-renew',
metavar='EXECUTABLE_PATH',
help='Path of an executable file to call after any renewal (CA cert, '
'certificate, revocation list).',
)
parser.add_argument(
'--user-key',
metavar='KEY_PATH',
help='User private key and certificate bundled in a single file to '
'authenticate with caucase.',
)
parser.add_argument(
'--mode',
default=MODE_SERVICE,
choices=[MODE_SERVICE, MODE_USER],
help='The type of certificates you want to manipulate: '
'<%s> certificates allow managing caucase server, '
'<%s> certificates can be validated by caucase\'s CA certificate. '
'default: %%(default)s' % (
MODE_USER,
MODE_SERVICE,
)
)
anonymous_group = parser.add_argument_group(
'Anonymous actions',
'Actions which do no require authentication.',
)
anonymous_group.add_argument(
'--send-csr',
nargs='+',
metavar='CSR_PATH',
default=[],
help='Request signature of these certificate signing requests.',
)
anonymous_group.add_argument(
'--get-crt',
nargs=2,
action='append',
default=[],
metavar=('CSR_ID', 'CRL_PATH'),
help='Retrieve the certificate identified by '
'identifier and store it at given path. '
'If CSR_PATH exists and contains the private key corresponding to '
'received certificate, certificate will be appended to that file. '
'Can be given multiple times.',
)
anonymous_group.add_argument(
'--revoke-crt',
nargs=2,
action='append',
default=[],
metavar=('CRT_PATH', 'KEY_PATH'),
help='Revoke certificate. If CRT_PATH file contains both a certificate '
'and a key, KEY_PATH is ignored. '
'Can be given multiple times.',
)
anonymous_group.add_argument(
'--renew-crt',
nargs=2,
default=[],
action='append',
metavar=('CRT_PATH', 'KEY_PATH'),
help='Renew certificates in-place if they exceed THRESHOLD. '
'If CRT_PATH file contains both certificate and key, KEY_PATH is ignored '
'and CRT_PATH receives both the new key and the new certificate. '
'Can be given multiple times.',
)
anonymous_group.add_argument(
'--get-csr',
nargs=2,
default=[],
action='append',
metavar=('CSR_ID', 'CSR_PATH'),
help='Retrieve certificate signing request and append to CSR_PATH. '
'Should only be needed before deciding to sign or reject the request. '
'Can be given multiple times.',
)
anonymous_group.add_argument(
'--update-user',
action='store_true',
help='Update or create user CA and CRL. '
'Should only be needed by the https server in front of caucase.'
)
def main():
manager.run()
authenticated_group = parser.add_argument_group(
'Authenticated actions',
'Actions which require an authentication. Requires --user-key .',
)
authenticated_group.add_argument(
'--list-csr',
action='store_true',
help='List certificate signing requests currently pending on server.',
)
authenticated_group.add_argument(
'--sign-csr',
nargs='+',
default=[],
metavar='CSR_ID',
help='Sign pending certificate signing requests.',
)
authenticated_group.add_argument(
'--sign-csr-with',
nargs=2,
default=[],
action='append',
metavar=('CSR_ID', 'CSR_PATH'),
help='Sign pending certificate signing request, but use provided CSR for '
'requested subject and extensions instead of stored CSR. '
'Can be given multiple times.',
)
authenticated_group.add_argument(
'--reject-csr',
nargs='+',
default=[],
metavar='CSR_ID',
help='Reject these pending certificate signing requests.',
)
authenticated_group.add_argument(
'--revoke-other-crt',
nargs='+',
default=[],
metavar='CRT_PATH',
help='Revoke certificate without needing access to their private key.'
)
authenticated_group.add_argument(
'--revoke-serial',
nargs='+',
default=[],
metavar='SERIAL',
type=int,
help='Revoke certificate by serial number, without needing the '
'certificate at all. DANGEROUS: typos will not be detected ! '
'COSTLY: revocation will stay in the revocation list until all '
'currently valid CA certificates have expired. '
'Use --revoke and --revoke-other-crt whenever possible.',
)
args = parser.parse_args(argv)
sign_csr_id_set = set(args.sign_csr)
sign_with_csr_id_set = {x for x, _ in args.sign_csr_with}
if (
sign_csr_id_set.intersection(args.reject_csr) or
sign_with_csr_id_set.intersection(args.reject_csr) or
sign_csr_id_set.intersection(sign_with_csr_id_set)
):
print >>sys.stderr, (
'A given CSR_ID cannot be in more than one of --sign-csr, '
'--sign-csr-with and --reject-csr'
)
raise SystemExit(STATUS_ERROR)
updated = False
warning = False
error = False
finished = False
cau_url = args.ca_url + '/cau'
cas_url = args.ca_url + '/cas'
try:
# Get a working, up-to-date CAS CA certificate file.
updated |= updateCAFile(cas_url, args.ca_crt)
# --update-user, CA part
if args.update_user or args.mode == MODE_USER:
updated |= updateCAFile(cau_url, args.user_ca_crt)
client = CLICaucaseClient(
client=CaucaseClient(
ca_url={
MODE_SERVICE: cas_url,
MODE_USER: cau_url,
}[args.mode],
ca_crt_pem_list=utils.getCertList(args.ca_crt),
user_key=args.user_key,
),
)
ca_list = [
utils.load_ca_certificate(x)
for x in utils.getCertList({
MODE_SERVICE: args.ca_crt,
MODE_USER: args.user_ca_crt,
}[args.mode])
]
client.putCSR(args.send_csr)
client.getCSR(args.get_csr)
warning, error = client.getCRT(warning, error, args.get_crt, ca_list)
error = client.revokeCRT(error, args.revoke_crt)
updated, error = client.renewCRT(
crt_key_list=args.renew_crt,
renewal_deadline=datetime.datetime.utcnow() + datetime.timedelta(
args.threshold,
0,
),
key_len=args.key_len,
ca_certificate_list=ca_list,
updated=updated,
error=error,
)
client.signCSR(args.sign_csr)
client.signCSRWith(args.sign_csr_with)
client.rejectCSR(args.reject_csr)
error |= client.revokeOtherCRT(args.revoke_other_crt)
client.revokeSerial(args.revoke_serial)
# show latest CSR list status
if args.list_csr:
client.listCSR(args.mode)
# update our CRL after all revocations we were requested
updated |= updateCRLFile(cas_url, args.crl, [
utils.load_ca_certificate(x)
for x in utils.getCertList(args.ca_crt)
])
# --update-user, CRL part
if args.update_user:
updated |= updateCRLFile(cau_url, args.user_crl, [
utils.load_ca_certificate(x)
for x in utils.getCertList(args.user_ca_crt)
])
finished = True
finally:
if updated and args.on_renew:
status = os.system(args.on_renew)
# Avoid raising if we arrived here because of an exception, to not hide
# the original problem.
if finished and status:
raise SystemExit(STATUS_CALLBACK_ERROR)
if error:
raise SystemExit(STATUS_ERROR)
if warning:
raise SystemExit(STATUS_WARNING)
def probe(argv=None):
"""
Verify basic caucase server functionality
"""
parser = argparse.ArgumentParser(
description='caucase probe - Verify basic caucase server functionality',
)
parser.add_argument(
'ca_url',
nargs=1,
help='caucase service HTTP base URL.',
)
ca_url, = parser.parse_args(argv).ca_url
cas_url = ca_url + '/cas'
http_client = CaucaseClient(
ca_url=cas_url,
)
http_ca_pem = http_client.getCA()
https_ca_pem = HTTPSOnlyCaucaseClient(
ca_url=cas_url,
ca_crt_pem_list=[http_ca_pem],
).getCA()
# Retrieve again in case there was a renewal between both calls - we do
# not expect 2 renewals in very short succession.
http2_ca_pem = http_client.getCA()
if https_ca_pem not in (http_ca_pem, http2_ca_pem):
raise ValueError('http and https do not serve the same caucase database')
def monitor(argv=None):
"""
Bootstrap certificate and companion files and keep them up-to-date.
"""
parser = argparse.ArgumentParser(
description='caucase monitor - '
'Bootstrap certificate and companion files and keep them up-to-date',
)
parser.add_argument(
'--ca-url',
required=True,
metavar='URL',
help='caucase service HTTP base URL.',
)
parser.add_argument(
'--cas-ca',
required=True,
metavar='CRT_PATH',
help='Service CA certificate file location used to verify connection '
'to caucase. Will be maintained up-to-date. '
'default: %(default)s',
)
parser.add_argument(
'--threshold',
default=31,
type=float,
help='The remaining certificate validity period, in days, under '
'which a renew is desired. default: %(default)s',
)
parser.add_argument(
'--key-len',
default=2048,
type=int,
metavar='BITLENGTH',
help='Number of bits to use when generating a new private key. '
'default: %(default)s',
)
parser.add_argument(
'--on-renew',
metavar='EXECUTABLE_PATH',
help='Path of an executable file to call after any renewal (CA cert, '
'certificate, revocation list).',
)
parser.add_argument(
'--max-sleep',
default=31,
type=float,
help='Maximum number of days to sleep for. Allows refreshing the CRL '
'more often on sensitive services. default: %(default)s',
)
parser.add_argument(
'--mode',
default=MODE_SERVICE,
choices=[MODE_SERVICE, MODE_USER],
help='The type of certificates you want to manipulate: '
'<%s> certificates allow managing caucase server, '
'<%s> certificates can be validated by caucase\'s CA certificate. '
'default: %%(default)s' % (
MODE_USER,
MODE_SERVICE,
)
)
parser.add_argument(
'--csr',
metavar='CSR_PATH',
help='Path of your CSR to use for initial request of a certificate for '
'MODE. Ignored once a certificate exists at the location given by '
'--crt .',
)
parser.add_argument(
'--key',
metavar='KEY_PATH',
help='Path of your private key file. Must always exist when this command '
'is started. Will be updated on certificate renewal. If not provided, both '
'key and certificate will be stored in the file pointed at by --crt .',
)
parser.add_argument(
'--crt',
required=True,
metavar='CRT_PATH',
help='Path of your certificate for MODE. Will be renewed before '
'expiration.',
)
parser.add_argument(
'--ca',
required=True,
metavar='CRT_PATH',
help='Path of your CA certificate for MODE. '
'Will be maintained up-to-date.'
)
parser.add_argument(
'--crl',
required=True,
metavar='CRT_PATH',
help='Path of your certificate revocation list for MODE. '
'Will be maintained up-to-date.'
)
args = parser.parse_args(argv)
try:
cas_url = args.ca_url + '/cas'
ca_url = {
MODE_SERVICE: cas_url,
MODE_USER: args.ca_url + '/cau',
}[args.mode]
threshold = datetime.timedelta(args.threshold, 0)
max_sleep = datetime.timedelta(args.max_sleep, 0)
updated = updateCAFile(cas_url, args.cas_ca) and args.cas_ca == args.ca
client = CaucaseClient(
ca_url=ca_url,
ca_crt_pem_list=utils.getCertList(args.cas_ca)
)
if not utils.hasOneCert(args.crt):
print 'Bootstraping...'
csr_pem = utils.getCertRequest(args.csr)
# Quick sanity check before bothering server
utils.load_certificate_request(csr_pem)
csr_id = client.putCSR(csr_pem)
print 'Waiting for signature of', csr_id
while True:
try:
crt_pem = client.getCRT(csr_id)
except CaucaseError, e:
if e.args[0] != httplib.NOT_FOUND:
raise
# If server does not know our CSR anymore, getCSR will raise.
# If it does, we were likely rejected, so exit by letting exception
# through.
client.getCSR(csr_id)
# Still here ? Ok, wait a bit and try again.
utils.interruptibleSleep(60)
else:
with open(args.crt, 'a') as crt_file:
crt_file.write(crt_pem)
updated = True
break
print 'Bootstrap done'
next_deadline = datetime.datetime.utcnow()
while True:
print 'Next wake-up at', next_deadline.strftime(
'%Y-%m-%d %H:%M:%S +0000'
)
now = utils.until(next_deadline)
if args.cas_ca != args.ca and updateCAFile(cas_url, args.cas_ca):
client = CaucaseClient(
ca_url=ca_url,
ca_crt_pem_list=utils.getCertList(args.cas_ca)
)
if updateCAFile(ca_url, args.ca):
print 'Got new CA'
updated = True
ca_crt_list = [
utils.load_ca_certificate(x)
for x in utils.getCertList(args.ca)
]
if updateCRLFile(ca_url, args.crl, ca_crt_list):
print 'Got new CRL'
updated = True
crt_pem, key_pem, key_path = utils.getKeyPair(args.crt, args.key)
crt = utils.load_certificate(crt_pem, ca_crt_list, None)
next_deadline = crt.not_valid_after - threshold
if next_deadline <= now:
print 'Renewing', args.crt
new_key_pem, new_crt_pem = client.renewCRT(
old_crt=crt,
old_key=utils.load_privatekey(key_pem),
key_len=args.key_len,
)
if key_path is None:
with open(args.crt, 'w') as crt_file:
crt_file.write(new_key_pem)
crt_file.write(new_crt_pem)
else:
with open(args.crt, 'w') as crt_file, open(key_path, 'w') as key_file:
key_file.write(new_key_pem)
crt_file.write(new_crt_pem)
updated = True
next_deadline = min(
next_deadline,
utils.load_crl(open(args.crl).read(), ca_crt_list).next_update,
now + max_sleep,
)
if updated:
if args.on_renew is not None:
status = os.system(args.on_renew)
if status:
print >>sys.stderr, 'Renewal hook exited with status:', status
raise SystemExit(STATUS_ERROR)
updated = False
except (utils.SleepInterrupt, SystemExit):
# Not intercepting KeyboardInterrupt so interrupting outside of
# interruptibleSleep shows where the script got interrupted.
pass
def rerequest(argv=None):
"""
Produce a new private key and sign a CSR created by copying an existing,
well-signed CSR.
"""
parser = argparse.ArgumentParser(
description='caucase rerequest - '
'Produce a new private key and sign a CSR created by copying an existing, '
'well-signed CSR.',
)
parser.add_argument(
'--template',
required=True,
type=argparse.FileType('r'),
help='Existing PEM-encodd CSR to use as a template.',
)
parser.add_argument(
'--csr',
required=True,
help='Path of produced PEM-encoded CSR.',
)
parser.add_argument(
'--key',
required=True,
help='Path of produced PEM-encoded private key.',
)
parser.add_argument(
'--key-len',
default=2048,
type=int,
metavar='BITLENGTH',
help='Number of bits to use when generating a new private key. '
'default: %(default)s',
)
args = parser.parse_args(argv)
template = utils.load_certificate_request(utils.getCertRequest(args.template))
key = utils.generatePrivateKey(key_len=args.key_len)
csr_pem = utils.dump_certificate_request(
x509.CertificateSigningRequestBuilder(
subject_name=template.subject,
extensions=template.extensions,
).sign(
private_key=key,
algorithm=utils.DEFAULT_DIGEST_CLASS(),
backend=_cryptography_backend,
),
)
key_pem = utils.dump_privatekey(key)
orig_umask = os.umask(0177)
try:
with open(args.key, 'w') as key_file:
key_file.write(key_pem)
finally:
os.umask(orig_umask)
with open(args.csr, 'w') as csr_file:
csr_file.write(csr_pem)
def key_id(argv=None):
"""
Displays key identifier from private key, and the list of acceptable key
identifiers for a given backup file.
"""
parser = argparse.ArgumentParser(
description='caucase key id - '
'Displays key identifier from private key, and the list of acceptable key'
'identifiers for a given backup file.',
)
parser.add_argument(
'--private-key',
nargs='+',
default=(),
help='PEM-encoded keys to display the identifier of.',
)
parser.add_argument(
'--backup',
nargs='+',
default=(),
help='Caucase backup files to display acceptable deciphering key '
'identifiers of.',
)
args = parser.parse_args(argv)
for key_path in args.private_key:
print key_path, x509.SubjectKeyIdentifier.from_public_key(
utils.load_privatekey(open(key_path).read()).public_key(),
).digest.encode('hex')
for backup_path in args.backup:
print backup_path
with open(backup_path) as backup_file:
magic = backup_file.read(8)
if magic != 'caucase\0':
raise ValueError('Invalid backup magic string')
header_len, = struct.unpack(
'<I',
backup_file.read(struct.calcsize('<I')),
)
for key_entry in json.loads(backup_file.read(header_len))['key_list']:
print ' ', key_entry['id']
# This file is part of caucase
# Copyright (C) 2017 Nexedi
# Alain Takoudjou <alain.takoudjou@nexedi.com>
# Vincent Pelletier <vincent@nexedi.com>
#
# caucase is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# caucase is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
import os, errno
import time
import ConfigParser
import logging
import requests
import argparse
import traceback
import pem
import json
import subprocess
import hashlib
from OpenSSL import crypto
from caucase import utils
from datetime import datetime, timedelta
CSR_KEY_FILE = 'csr.key.txt'
RENEW_CSR_KEY_FILE = 'renew_csr.key.txt'
def popenCommunicate(command_list):
subprocess_kw = dict(stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
popen = subprocess.Popen(command_list, **subprocess_kw)
result = popen.communicate()[0]
if popen.returncode is None:
popen.kill()
if popen.returncode != 0:
raise ValueError('Issue during calling %r, result was:\n%s' % (
command_list, result))
return result
def parseArguments():
"""
Parse arguments for Certificate Authority Request.
"""
parser = argparse.ArgumentParser()
parser.add_argument('--ca-url',
required=True,
help='Certificate Authority URL')
parser.add_argument('-c', '--ca-crt-file',
default='ca.crt.pem',
help='Path for CA Cert file. default: %(default)s')
parser.add_argument('-x', '--crt-file',
default='crt.pem',
help='Path for Certificate file. default: %(default)s')
parser.add_argument('-k', '--key-file',
default='key.pem',
help='Path of key file. default: %(default)s')
parser.add_argument('-s', '--csr-file',
default='csr.pem',
help='Path where to store csr file. default: %(default)s')
parser.add_argument('-r', '--crl-file',
default='crl.pem',
help='Path where to store crl file. default: %(default)s')
parser.add_argument('--digest',
default="sha256",
help='Digest used to sign data. default: %(default)s')
parser.add_argument('--cn',
help='Common name to use when request new certificate.')
parser.add_argument('--threshold',
help='The minimum remaining certificate validity time in' \
' seconds after which renew of certificate can be triggered.',
type=int)
parser.add_argument('--on-renew',
help='Path of an executable file to call after certificate'\
' renewal.')
parser.add_argument('--on-crl-update',
help='Path of an executable file to call after CRL '\
'file update.')
parser.add_argument('--no-check-certificate',
action='store_false', default=True, dest='verify_certificate',
help='When connecting to CA on HTTPS, disable certificate verification.')
group = parser.add_mutually_exclusive_group()
group.add_argument('--request', action='store_true',
help='Request a new Certificate.')
group.add_argument('--revoke', action='store_true',
help='Revoke existing certificate.')
group.add_argument('--renew', action='store_true',
help='Renew current certificate and and replace with existing files.')
group.add_argument('--update-crl', action='store_true',
help='Download and store the new CRL file if there was a new revocation.')
return parser
def requestCertificate(ca_request, config):
# download or update ca crt file
ca_request.getCACertificateChain()
if os.path.exists(config.crt_file):
return
if not os.path.exists(config.csr_file):
csr = ca_request.generateCertificateRequest(config.key_file,
cn=config.cn, csr_file=config.csr_file)
else:
csr = open(config.csr_file).read()
ca_request.signCertificate(csr)
def revokeCertificate(ca_revoke, config):
os.close(os.open(config.key_file, os.O_RDONLY))
os.close(os.open(config.crt_file, os.O_RDONLY))
# download or update ca crt file
ca_revoke.getCACertificateChain()
ca_revoke.revokeCertificate()
def renewCertificate(ca_renew, config, backup_dir):
os.close(os.open(config.key_file, os.O_RDONLY))
os.close(os.open(config.crt_file, os.O_RDONLY))
# download or update ca crt file
ca_renew.getCACertificateChain()
ca_renew.renewCertificate(config.csr_file,
backup_dir,
config.threshold,
after_script=config.on_renew)
def main():
parser = parseArguments()
config = parser.parse_args()
base_dir = os.path.dirname(config.crt_file)
os.chdir(os.path.abspath(base_dir))
if not config.ca_url:
parser.error('`ca-url` parameter is required. Use --ca-url URL')
parser.print_help()
exit(1)
ca_client = CertificateAuthorityRequest(config.key_file, config.crt_file,
config.ca_crt_file, config.ca_url, digest=config.digest,
verify_certificate=config.verify_certificate)
if config.request:
if not config.cn:
parser.error('Option --cn is required for request.')
parser.print_help()
exit(1)
requestCertificate(ca_client, config)
elif config.revoke:
revokeCertificate(ca_client, config)
elif config.renew:
if not config.threshold:
parser.error('`threshold` parameter is required with renew. Use --threshold VALUE')
parser.print_help()
exit(1)
backup_dir = os.path.join('.',
'backup-%s' % datetime.now().strftime('%Y-%m-%d-%H%M%S'))
# cleanup
if os.path.exists(CSR_KEY_FILE):
os.unlink(CSR_KEY_FILE)
if os.path.exists(config.csr_file):
os.unlink(config.csr_file)
renewCertificate(ca_client, config, backup_dir)
elif config.update_crl:
ca_client.updateCertificateRevocationList(config.crl_file,
after_script=config.on_crl_update)
else:
parser.error('Please set one of options: --request | --revoke | --renew | --update-crl.')
parser.print_help()
exit(1)
class CertificateAuthorityRequest(object):
def __init__(self, key, certificate, cacertificate, ca_url,
max_retry=10, digest="sha256", sleep_time=5,
verify_certificate=False, logger=None):
self.key = key
self.certificate = certificate
self.cacertificate = cacertificate
self.ca_url = ca_url
self.logger = logger
# maximum retry number of post/put request
self.max_retry = max_retry
# time to sleep before retry failed request
self.sleep_time = sleep_time
self.digest = digest
self.extension_manager = utils.X509Extension()
self.ca_certificate_list = []
self.verify_certificate = verify_certificate
while self.ca_url.endswith('/'):
# remove all / at end or ca_url
self.ca_url = self.ca_url[:-1]
if os.path.exists(self.cacertificate):
self.ca_certificate_list = [
crypto.load_certificate(crypto.FILETYPE_PEM, x._pem_bytes) for x in
pem.parse_file(self.cacertificate)
]
if self.logger is None:
self.logger = logging.getLogger('Caucase Client')
self.logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
handler.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
self.logger.addHandler(handler)
self.generatePrivatekey(self.key)
def _request(self, method, url, data=None):
try:
req = getattr(requests, method)
kw = {}
if data:
kw['data'] = data
kw['verify'] = self.verify_certificate
return req(url, **kw)
except requests.ConnectionError, e:
self.logger.error("Got ConnectionError while sending request to CA. Url is %s\n%s" % (
url, str(e)))
return None
def _checkCertEquals(self, first_cert, second_cert):
"""
Say if two certificate PEM object are the same
XXX - more checks should be done ?
"""
return first_cert.set_subject().CN == second_cert.get_subject().CN and \
first_cert.get_serial_number() == second_cert.get_serial_number()
def _writeNewFile(self, file_path, content, mode=0644):
fd = os.open(file_path,
os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_TRUNC, mode)
try:
os.write(fd, content)
finally:
os.close(fd)
def _sendCertificateSigningRequest(self, csr_string):
request_url = '%s/csr' % self.ca_url
data = {'csr': csr_string}
retry = 0
response = self._request('put', request_url, data=data)
while (not response or response.status_code != 201) and retry < self.max_retry:
self.logger.error("%s: Failed to sent CSR. \n%s" % (
response.status_code, response.text))
self.logger.info("will retry in %s seconds..." % self.sleep_time)
time.sleep(self.sleep_time)
retry += 1
response = self._request('put', request_url, data=data)
if not response or response.status_code != 201:
raise Exception("ERROR: failed to send CSR after %s retry." % retry)
self.logger.info("CSR succefully sent.")
# Get csr Location from request header: http://xxx.com/csr/key
self.logger.debug("CSR location is: %s" % response.headers['Location'])
csr_key = response.headers['Location'].split('/')[-1]
with open(CSR_KEY_FILE, 'w') as fkey:
fkey.write(csr_key)
return csr_key
def _sendCertificateRenewal(self, cert, csr):
payload = dict(renew_csr=csr, crt=cert)
pkey = open(self.key).read()
wrapped = utils.wrap(payload, pkey, [self.digest])
request_url = '%s/crt/renew' % self.ca_url
data = {'payload': json.dumps(wrapped)}
self.logger.info("Sending Certificate Renewal request...")
response = self._request('put', request_url, data=data)
break_code = [201, 404, 500, 404]
retry = 1
while response is None or response.status_code not in break_code:
self.logger.error("%s: Failed to send renewal request. \n%s" % (
response.status_code, response.text))
self.logger.info("will retry in %s seconds..." % self.sleep_time)
time.sleep(self.sleep_time)
response = self._request('put', request_url, data=data)
retry += 1
if retry > self.max_retry:
break
if not response or response.status_code != 201:
raise Exception("ERROR: failed to send certificate renewal request "\
"after %s retry.\n%s" % (
retry, response.text))
csr_key = response.headers['Location'].split('/')[-1]
with open(RENEW_CSR_KEY_FILE, 'w') as fkey:
fkey.write(csr_key)
return csr_key
def _getSignedCertificate(self, crt_id):
reply_url = '%s/crt/%s' % (self.ca_url, crt_id)
response = self._request('get', reply_url)
while not response or response.status_code != 200:
time.sleep(self.sleep_time)
response = self._request('get', reply_url)
return response.text
def generateCertificateRequest(self, key_file, cn,
country='', state='', locality='', email='', organization='',
organization_unit='', csr_file=None):
"""
Generate certificate Signature request.
Parameter `cn` is mandatory
"""
with open(key_file) as fkey:
key = crypto.load_privatekey(crypto.FILETYPE_PEM, fkey.read())
req = crypto.X509Req()
subject = req.get_subject()
subject.CN = cn
if country:
subject.C = country
if state:
subject.ST = state
if locality:
subject.L = locality
if organization:
subject.O = organization
if organization_unit:
subject.OU = organization_unit
if email:
subject.emailAddress = email
req.set_pubkey(key)
self.extension_manager.setDefaultCsrExtensions(req)
req.sign(key, self.digest)
csr = crypto.dump_certificate_request(crypto.FILETYPE_PEM, req)
if csr_file is not None:
with open(csr_file, 'w') as req_file:
req_file.write(csr)
os.chmod(csr_file, 0640)
return csr
def generatePrivatekey(self, output_file, size=2048):
"""
Generate private key into `output_file`
"""
try:
key_fd = os.open(output_file,
os.O_CREAT|os.O_WRONLY|os.O_EXCL|os.O_TRUNC,
0600)
except OSError, e:
if e.errno != errno.EEXIST:
raise
else:
key = crypto.PKey()
key.generate_key(crypto.TYPE_RSA, size)
os.write(key_fd, crypto.dump_privatekey(crypto.FILETYPE_PEM, key))
os.close(key_fd)
def checkCertificateValidity(self, cert):
"""
validate the certificate PEM string with the CA Certificate and private key
"""
cert_pem = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
pkey = open(self.key).read()
key_pem = crypto.load_privatekey(crypto.FILETYPE_PEM, pkey)
return utils.checkCertificateValidity(
self.ca_certificate_list,
cert_pem,
key_pem)
def isCertExpirationDateValid(self, x509, threshold):
"""
Return True if remaning certificate valid time is second is lower than
the threshold value
"""
expiration_date = datetime.strptime(
x509.get_notAfter(), '%Y%m%d%H%M%SZ'
)
now_date = datetime.utcnow()
limit_date = now_date + timedelta(0, threshold)
expire_in = expiration_date - limit_date
if expire_in.days > 0.0:
return True
return False
def updateCACertificateChain(self):
"""
Request to CA all valid certificates an update in to cacertificate file
@note: if the CA has more that one valid certificate, the cacertificate
file will be updated contain concatenated cert them like:
CA_1
CA_2
...
CA_N
"""
ca_cert_url = '%s/crt/ca.crt.json' % self.ca_url
self.logger.info("Updating CA certificate file from %s" % ca_cert_url)
cert_list = response_json = []
cert_list_chain = ""
response = self._request('get', ca_cert_url)
while not response or response.status_code != 200:
# sleep a bit then try again until ca cert is ready
time.sleep(10)
response = self._request('get', ca_cert_url)
response_json = json.loads(response.text)
if len(response_json) > 0:
iter_ca_cert = iter(response_json)
is_valid = False
payload = utils.unwrap(iter_ca_cert.next(), lambda x: x['old'], [self.digest])
# check that old certificate is known
old_x509 = crypto.load_certificate(crypto.FILETYPE_PEM, payload['old'])
for x509 in self.ca_certificate_list:
if self._checkCertEquals(x509, old_x509):
is_valid = True
if not is_valid:
# no local certificate matches
raise CertificateVerificationError("Updated CA Certificate chain could " \
"not be validated using local CA Certificate at %r. \nYou can " \
"try removing your local ca file if it was not updated for more " \
"that a year." % self.cacertificate)
# if not old_x509.has_expired():
# XXX - TODO: check if expired old_x509 can break certificate validation
cert_list.append(old_x509)
cert_list.append(
crypto.load_certificate(crypto.FILETYPE_PEM, payload['new'])
)
cert_list_chain = "%s\n%s" % (payload['old'], payload['new'])
for next_item in iter_ca_cert:
payload = utils.unwrap(next_item, lambda x: x['old'], [self.digest])
old_x509 = crypto.load_certificate(crypto.FILETYPE_PEM, payload['old'])
if self._checkCertEquals(cert_list[-1], old_x509):
cert_list.append(
crypto.load_certificate(crypto.FILETYPE_PEM, payload['new'])
)
cert_list_chain += "\n%s" % payload['new']
else:
raise CertificateVerificationError("Get CA Certificate chain " \
"retourned %s \n\nbut validation of data failed" % response_json)
# dump into file
if not cert_list:
# Nothing to do...
return
self.ca_certificate_list = cert_list
fd = os.open(self.cacertificate, os.O_CREAT|os.O_WRONLY, 0640)
try:
os.write(fd, cert_list_chain)
finally:
os.close(fd)
def getCACertificateChain(self):
"""
Get CA certificate file.
If it's the first download, get the latest valid certificate at ca.crt.pem
else, update current cacertificate with list of valid ca certificat chain
"""
# If cert file exists exist
if os.path.exists(self.cacertificate) and os.stat(self.cacertificate).st_size > 0:
# Get all valids CA certificate
return self.updateCACertificateChain()
ca_cert_url = '%s/crt/ca.crt.pem' % self.ca_url
self.logger.info("getting CA certificate file %s" % ca_cert_url)
response = None
while not response or response.status_code != 200:
response = self._request('get', ca_cert_url)
if response is not None:
try:
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, response.text)
except crypto.Error, e:
# XXX - we got a bad certificate, break here ?
traceback.print_exc()
response = None
else:
self.ca_certificate_list = [x509]
break
# sleep a bit then try again until ca cert is ready
time.sleep(10)
fd = os.open(self.cacertificate,
os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_TRUNC, 0640)
try:
os.write(fd, response.text)
finally:
os.close(fd)
def signCertificate(self, csr):
"""
Send certificate signature request and wait until the certificate is
signed.
csr parameter is string in PEM format
"""
if os.path.exists(self.certificate) and os.stat(self.certificate).st_size > 0:
# exit because the certificate exists
return
csr_key = ""
self.logger.info("Request signed certificate from CA...")
if os.path.exists(CSR_KEY_FILE):
with open(CSR_KEY_FILE) as fkey:
csr_key = fkey.read()
if csr_key:
self.logger.info("Csr was already sent to CA, using csr : %s" % csr_key)
else:
csr_key = self._sendCertificateSigningRequest(csr)
self.logger.info("Waiting for signed certificate...")
# csr is xxx.csr.pem so cert is xxx.cert.pem
certificate = self._getSignedCertificate('%s.crt.pem' % csr_key[:-8])
self.logger.info("Validating signed certificate...")
if not self.checkCertificateValidity(certificate):
# certificate verification failed, should raise ?
self.logger.warn("Certificate validation failed.\n" \
"Please double check the signed certificate before use. Also consider" \
"revoke it and request a new signed certificate.")
fd = os.open(self.certificate,
os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_TRUNC, 0644)
try:
os.write(fd, certificate)
finally:
os.close(fd)
self.logger.info("Certificate correctly saved at %s." % self.certificate)
def revokeCertificate(self, message=""):
"""
Revoke the current certificate on CA.
"""
retry = 1
pkey = open(self.key).read()
cert = open(self.certificate).read()
cert_pem = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
payload = dict(
reason=message,
revoke_crt=cert)
wrapped = utils.wrap(payload, pkey, [self.digest])
request_url = '%s/crt/revoke' % self.ca_url
data = {'payload': json.dumps(wrapped)}
self.logger.info("Sending Certificate revocation request of CN: %s." % (
cert_pem.get_subject().CN))
response = self._request('put', request_url, data=data)
break_code = [201, 404, 500, 404]
while response is None or response.status_code not in break_code:
self.logger.error("%s: Failed to send revoke request. \n%s" % (
response.status_code, response.text))
self.logger.info("will retry in %s seconds..." % self.sleep_time)
time.sleep(self.sleep_time)
response = self._request('put', request_url, data=data)
retry += 1
if retry > self.max_retry:
break
if not response or response.status_code != 201:
raise Exception("ERROR: failed to put revoke certificate after %s retry. Exiting..." % retry)
self.logger.info("Certificate %s was successfully revoked." % (
self.certificate))
def renewCertificate(self, csr_file, backup_dir, threshold, renew_key=True,
after_script=''):
"""
Renew the current certificate. Regenerate private key if renew_key is `True`
"""
new_key_path = '%s.renew' % self.key
new_cert_path = '%s.renew' % self.certificate
key_file = self.key
cert = open(self.certificate).read()
cert_pem = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
csr_key = ""
if self.isCertExpirationDateValid(cert_pem, threshold):
self.logger.info("Nothing to do, no need to renew the certificate.")
return
try:
if renew_key:
self.generatePrivatekey(new_key_path)
key_file = new_key_path
if os.path.exists(RENEW_CSR_KEY_FILE):
csr_key = open(RENEW_CSR_KEY_FILE).read()
if not csr_key:
if not os.path.exists(csr_file):
csr = self.generateCertificateRequest(key_file,
cn=cert_pem.get_subject().CN,
csr_file=csr_file)
else:
csr = open(csr_file).read()
csr_key = self._sendCertificateRenewal(cert, csr)
self.logger.info("Waiting for signed certificate...")
new_cert = self._getSignedCertificate('%s.crt.pem' % csr_key[:-8])
if not os.path.exists(backup_dir):
os.mkdir(backup_dir)
self._writeNewFile(new_cert_path, new_cert)
# change location of files
if renew_key:
os.rename(self.key,
os.path.join(backup_dir, os.path.basename(self.key)))
os.rename(new_key_path, self.key)
self.logger.info("Private correctly renewed at %s." % self.key)
os.rename(self.certificate,
os.path.join(backup_dir, os.path.basename(self.certificate)))
os.rename(new_cert_path, self.certificate)
self.logger.info("Validating signed certificate...")
if not self.checkCertificateValidity(new_cert):
# certificate verification failed, should raise ?
self.logger.warn("Certificate validation failed.\n" \
"Please double check the signed certificate before use. Also consider" \
"revoke it and request a new signed certificate.")
else:
self.logger.info("Certificate correctly renewed at %s." % self.certificate)
except:
raise
else:
for path in [csr_file, RENEW_CSR_KEY_FILE]:
if os.path.exists(path):
os.unlink(path)
if after_script:
output = popenCommunicate([os.path.realpath(after_script)])
self.logger.info("Successfully executed script '%s' with output:\n%s" % (
after_script, output))
finally:
for path in [new_cert_path, new_key_path]:
if os.path.exists(path):
os.unlink(path)
def updateCertificateRevocationList(self, crl_file, after_script=''):
"""
Download or update crl. If the crl_file exists, it will be updated if
the new CRL has changed.
"""
crl_url = '%s/crl' % self.ca_url
self.logger.info("Downloading crl file from %s ..." % crl_url)
response = self._request('get', crl_url)
retry = 1
while not response or response.status_code != 200:
time.sleep(self.sleep_time)
response = self._request('get', crl_url)
retry += 1
if retry > self.max_retry:
break
if not response or response.status_code != 200:
raise Exception("ERROR: failed to get crl file after %s retry. Exiting..." % retry)
crl_string = response.text
# load crl string so we are sure that it is a valid crl string
crl = crypto.load_crl(crypto.FILETYPE_PEM, crl_string)
# Dumped string contain only the CRL without extra info
crl_string = crypto.dump_crl(crypto.FILETYPE_PEM, crl)
update_crl = False
if os.path.exists(crl_file):
with open(crl_file) as fcrl:
old_checksum = hashlib.md5(fcrl.read()).hexdigest()
checksum = hashlib.md5(crl_string).hexdigest()
if checksum != old_checksum:
update_crl = True
else:
update_crl = True
if update_crl:
fd = os.open(crl_file, os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0644)
try:
os.write(fd, crl_string)
finally:
os.close(fd)
self.logger.info("New CRL file was saved in %s ..." % crl_file)
if after_script:
output = popenCommunicate([os.path.realpath(after_script)])
self.logger.info("Successfully executed script '%s' with output:\n%s" % (
after_script, output))
else:
self.logger.info("crl file don't need to be updated.")
# This file is part of caucase
# Copyright (C) 2017 Nexedi
# Alain Takoudjou <alain.takoudjou@nexedi.com>
# Vincent Pelletier <vincent@nexedi.com>
#
# caucase is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# caucase is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
"""
Caucase - Certificate Authority for Users, Certificate Authority for SErvices
"""
from __future__ import absolute_import
import datetime
import httplib
import json
import os
import ssl
from urlparse import urlparse
from cryptography import x509
from cryptography.hazmat.backends import default_backend
import cryptography.exceptions
from . import utils
__all__ = (
'CaucaseError',
'CaucaseClient',
'HTTPSOnlyCaucaseClient',
'updateCAFile',
'updateCRLFile',
)
_cryptography_backend = default_backend()
class CaucaseError(Exception):
"""
Raised when server responds with an HTTP error status.
"""
pass
def updateCAFile(url, ca_crt_path):
"""
Bootstrap anf maintain a CA file up-to-date.
url (str)
URL to caucase, ending in eithr /cas or /cau.
ca_crt_path (str)
Path to the CA certificate file, which may not exist.
Return whether an update happened (including whether an already-known
certificate expired and was discarded).
"""
if not os.path.exists(ca_crt_path):
ca_pem = CaucaseClient(
ca_url=url,
).getCA()
with open(ca_crt_path, 'w') as ca_crt_file:
ca_crt_file.write(ca_pem)
updated = True
else:
updated = False
now = datetime.datetime.utcnow()
loaded_ca_pem_list = utils.getCertList(ca_crt_path)
ca_pem_list = [
x
for x in loaded_ca_pem_list
if utils.load_ca_certificate(x).not_valid_after > now
]
ca_pem_list.extend(
CaucaseClient(
ca_url=url,
ca_crt_pem_list=ca_pem_list,
).getNewCAList(),
)
if ca_pem_list != loaded_ca_pem_list:
data = ''.join(ca_pem_list)
with open(ca_crt_path, 'w') as ca_crt_file:
ca_crt_file.write(data)
updated = True
return updated
def updateCRLFile(url, crl_path, ca_list):
"""
Bootstrap anf maintain a CRL file up-to-date.
url (str)
URL to caucase, ending in eithr /cas or /cau.
crl_path (str)
Path to the CRL file, which may not exist.
ca_list (list of cryptography.x509.Certificate instances)
One of these CA certificates must have signed the CRL for it to be
accepted.
Return whether an update happened.
"""
if os.path.exists(crl_path):
my_crl = utils.load_crl(open(crl_path).read(), ca_list)
else:
my_crl = None
latest_crl_pem = CaucaseClient(
ca_url=url,
).getCRL()
latest_crl = utils.load_crl(latest_crl_pem, ca_list)
if latest_crl != my_crl:
with open(crl_path, 'w') as crl_file:
crl_file.write(latest_crl_pem)
return True
return False
class CaucaseClient(object):
"""
Caucase HTTP(S) client.
Expose caucase REST API as pythonic methods.
"""
def __init__(self, ca_url, ca_crt_pem_list=None, user_key=None):
# XXX: set timeout to HTTP connections ?
http_url = urlparse(ca_url)
port = http_url.port or 80
self._http_connection = httplib.HTTPConnection(
http_url.hostname,
port,
#timeout=,
)
self._ca_crt_pem_list = ca_crt_pem_list
self._path = http_url.path
if ca_crt_pem_list:
ssl_context = ssl.create_default_context(
# unicode object needed as we use PEM, otherwise create_default_context
# expects DER.
cadata=''.join(ca_crt_pem_list).decode('ascii'),
)
if user_key:
ssl_context.load_cert_chain(user_key)
self._https_connection = httplib.HTTPSConnection(
http_url.hostname,
443 if port == 80 else port + 1,
#timeout=,
context=ssl_context,
)
def _request(self, connection, method, url, body=None, headers=None):
path = self._path + url
headers = headers or {}
connection.request(method, path, body, headers)
response = connection.getresponse()
response_body = response.read()
if response.status >= 400:
raise CaucaseError(response.status, response.getheaders(), response_body)
assert response.status < 300 # caucase does not redirect
if response.status == 201:
return response.getheader('Location')
return response_body
def _http(self, method, url, body=None, headers=None):
return self._request(self._http_connection, method, url, body, headers)
def _https(self, method, url, body=None, headers=None):
return self._request(self._https_connection, method, url, body, headers)
def getCRL(self):
"""
[ANONYMOUS] Retrieve latest CRL.
"""
return self._http('GET', '/crl')
def getCSR(self, csr_id):
"""
[ANONYMOUS] Retrieve an CSR by its identifier.
"""
return self._http('GET', '/csr/%i' % (csr_id, ))
def getCSRList(self):
"""
[AUTHENTICATED] Retrieve all pending CSRs.
"""
return [
{
y.encode('ascii'): z.encode('ascii') if isinstance(z, unicode) else z
for y, z in x.iteritems()
}
for x in json.loads(self._https('GET', '/csr'))
]
def putCSR(self, csr):
"""
[ANONYMOUS] Store a CSR and return its identifier.
"""
return int(self._http('PUT', '/csr', csr, {
'Content-Type': 'application/pkcs10',
}))
def deleteCSR(self, csr_id):
"""
[AUTHENTICATED] Reject a pending CSR.
"""
self._https('DELETE', '/csr/%i' % (csr_id, ))
def _getCRT(self, crt_id):
return self._http('GET', '/crt' + crt_id)
def getCRT(self, csr_id):
"""
[ANONYMOUS] Retrieve CRT by its identifier (same as corresponding CRL
identifier).
"""
return self._getCRT('/%i' % (csr_id, ))
def getCA(self):
"""
[ANONYMOUS] Retrieve current CA certificate.
"""
return self._getCRT('/ca.crt.pem')
def getNewCAList(self):
"""
[ANONYMOUS] Retrieve CA certificate chain, with CA certificate N+1 signed
by CA certificate N, allowing automated CA cert rollout.
"""
found = False
previous_ca = trust_anchor = sorted(
(
utils.load_ca_certificate(x)
for x in self._ca_crt_pem_list
),
key=lambda x: x.not_valid_before,
)[-1]
result = []
for entry in json.loads(self._getCRT('/ca.crt.json')):
try:
payload = utils.unwrap(
entry,
lambda x: x['old_pem'],
utils.DEFAULT_DIGEST_LIST,
)
except cryptography.exceptions.InvalidSignature:
continue
if not found:
found = utils.load_ca_certificate(
payload['old_pem'].encode('ascii'),
) == trust_anchor
if found:
if utils.load_ca_certificate(
payload['old_pem'].encode('ascii'),
) != previous_ca:
raise ValueError('CA signature chain broken')
new_pem = payload['new_pem'].encode('ascii')
result.append(new_pem)
previous_ca = utils.load_ca_certificate(new_pem)
return result
def renewCRT(self, old_crt, old_key, key_len):
"""
[ANONYMOUS] Request certificate renewal.
"""
new_key = utils.generatePrivateKey(key_len=key_len)
return (
utils.dump_privatekey(new_key),
self._http(
'PUT',
'/crt/renew',
json.dumps(
utils.wrap(
{
'crt_pem': utils.dump_certificate(old_crt),
'renew_csr_pem': utils.dump_certificate_request(
x509.CertificateSigningRequestBuilder(
).subject_name(
# Note: caucase server ignores this, but cryptography
# requires CSRs to have a subject.
old_crt.subject,
).sign(
private_key=new_key,
algorithm=utils.DEFAULT_DIGEST_CLASS(),
backend=_cryptography_backend,
),
),
},
old_key,
utils.DEFAULT_DIGEST,
),
),
{'Content-Type': 'application/json'},
),
)
def revokeCRT(self, crt, key=None):
"""
Revoke certificate.
[ANONYMOUS] if key is provided.
[AUTHENTICATED] if key is missing.
"""
if key:
method = self._http
data = utils.wrap(
{
'revoke_crt_pem': crt,
},
utils.load_privatekey(key),
utils.DEFAULT_DIGEST,
)
else:
method = self._https
data = utils.nullWrap({
'revoke_crt_pem': crt,
})
method(
'PUT',
'/crt/revoke',
json.dumps(data),
{'Content-Type': 'application/json'},
)
def revokeSerial(self, serial):
"""
Revoke certificate by serial.
This method is dangerous ! Prefer revokeCRT whenever possible.
[AUTHENTICATED]
"""
self._https(
'PUT',
'/crt/revoke',
json.dumps(utils.nullWrap({'revoke_serial': serial})),
{'Content-Type': 'application/json'},
)
def signCSR(self, csr_id, template_csr=''):
"""
[AUTHENTICATED] Sign certificate signing request.
"""
header_dict = {}
if template_csr:
header_dict['Content-Type'] = 'application/pkcs10'
self._https('PUT', '/crt/%i' % (csr_id, ), template_csr, header_dict)
class HTTPSOnlyCaucaseClient(CaucaseClient):
"""
Like CaucaseClient, but forces anonymous accesses to go through HTTPS as
well.
"""
def __init__(self, *args, **kw):
super(HTTPSOnlyCaucaseClient, self).__init__(*args, **kw)
self._http_connection = self._https_connection
......@@ -15,6 +15,9 @@
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
"""
Caucase - Certificate Authority for Users, Certificate Authority for SErvices
"""
class CertificateAuthorityException(Exception):
"""Base exception"""
......@@ -29,23 +32,9 @@ class NotFound(CertificateAuthorityException):
pass
class Found(CertificateAuthorityException):
"""Requested ID is already in use"""
class BadSignature(CertificateAuthorityException):
"""Non-x509 signature check failed"""
class BadCertificateSigningRequest(CertificateAuthorityException):
"""CSR content doesn't contain all required elements"""
pass
class BadCertificate(CertificateAuthorityException):
"""Certificate is not a valid PEM content"""
"""Resource to create already exists"""
pass
class CertificateVerificationError(CertificateAuthorityException):
"""Certificate is not valid, it was not signed by CA"""
pass
class ExpiredCertificate(CertificateAuthorityException):
"""Certificate has expired and could not be used"""
pass
\ No newline at end of file
# This file is part of caucase
# Copyright (C) 2017 Nexedi
# Alain Takoudjou <alain.takoudjou@nexedi.com>
# Vincent Pelletier <vincent@nexedi.com>
#
# caucase is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# caucase is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
"""
Caucase - Certificate Authority for Users, Certificate Authority for SErvices
"""
from __future__ import absolute_import
import argparse
import datetime
import glob
import os
import signal
import socket
from SocketServer import ThreadingMixIn
import ssl
import sys
import tempfile
from threading import Thread
from urlparse import urlparse
from wsgiref.simple_server import make_server, WSGIServer, WSGIRequestHandler
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from . import utils
from .wsgi import Application
from .ca import CertificateAuthority, UserCertificateAuthority
from .storage import SQLite3Storage
_cryptography_backend = default_backend()
BACKUP_SUFFIX = '.sql.caucased'
class ThreadingWSGIServer(ThreadingMixIn, WSGIServer):
"""
Threading WSGI server
"""
daemon_threads = True
def __init__(self, server_address, *args, **kw):
self.address_family, _, _, _, _ = socket.getaddrinfo(*server_address)[0]
assert self.address_family in (socket.AF_INET, socket.AF_INET6), self.address_family
WSGIServer.__init__(self, server_address, *args, **kw)
class CaucaseWSGIRequestHandler(WSGIRequestHandler):
"""
Make WSGIRequestHandler logging more apache-like.
"""
def log_date_time_string(self):
"""
Apache-style date format.
Compared to python's default (from BaseHTTPServer):
- ":" between day and time
- "+NNNN" timezone is displayed
- ...but, because of how impractical it is in python to get system current
timezone (including DST considerations), time it always logged in GMT
"""
now = datetime.datetime.utcnow()
return now.strftime('%d/' + self.monthname[now.month] + '/%Y:%H:%M:%S +0000')
class CaucaseSSLWSGIRequestHandler(CaucaseWSGIRequestHandler):
"""
Add SSL_CLIENT_CERT to environ when client has sent a certificate.
"""
ssl_client_cert_serial = '-'
def get_environ(self):
environ = WSGIRequestHandler.get_environ(self)
client_cert_der = self.request.getpeercert(binary_form=True)
if client_cert_der is not None:
cert = x509.load_der_x509_certificate(
client_cert_der,
_cryptography_backend,
)
self.ssl_client_cert_serial = str(cert.serial_number)
environ['SSL_CLIENT_CERT'] = utils.dump_certificate(cert)
return environ
# pylint: disable=redefined-builtin
def log_message(self, format, *args):
# Note: compared to BaseHTTPHandler, logs the client certificate serial as
# user name.
sys.stderr.write(
"%s - %s [%s] %s\n" % (
self.client_address[0],
self.ssl_client_cert_serial,
self.log_date_time_string(),
format % args,
)
)
# pylint: enable=redefined-builtin
def startServerThread(server):
"""
Create and start a "serve_forever" thread, and return it.
"""
server_thread = Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
def updateSSLContext(
https,
key_len,
threshold,
server_key_path,
hostname,
cau,
cas,
wrap=False,
):
"""
Build a new SSLContext with updated CA certificates, CRL and server key pair,
apply it to <https>.socket and return the datetime of next update.
"""
ssl_context = ssl.create_default_context(
purpose=ssl.Purpose.CLIENT_AUTH,
)
# SSL is used for client authentication, and is only required for very few
# users on any given caucased. So make ssl_context even stricter than python
# does.
# No TLSv1 and TLSv1.1, leaving (currently) only TLSv1.2
ssl_context.options |= ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1
# If a client wishes to use https for unauthenticated operations, that's
# fine too.
ssl_context.verify_mode = ssl.CERT_OPTIONAL
# Note: it does not seem possible to get python's openssl context to check
# certificate revocation:
# - calling load_verify_locations(cadata=<crl data>) or
# load_verify_locations(cadata=<crl data> + <ca crt data>) raises
# - calling load_verify_locations(cadata=<ca crt data> + <crl data>) fails to
# validate CA completely
# Anyway, wsgi application level is supposed (and automatically tested to)
# verify revocations too, so this should not be a big issue... Still,
# implementation cross-check would have been nice.
#ssl_context.verify_flags = ssl.VERIFY_CRL_CHECK_LEAF
ssl_context.load_verify_locations(
cadata=cau.getCACertificate().decode('ascii'),
)
cas_certificate_list = cas.getCACertificateList()
threshold_delta = datetime.timedelta(threshold, 0)
if os.path.exists(server_key_path):
old_crt_pem = utils.getCert(server_key_path)
old_crt = utils.load_certificate(old_crt_pem, cas_certificate_list, None)
if old_crt.not_valid_after - threshold_delta < datetime.datetime.utcnow():
new_key = utils.generatePrivateKey(key_len)
new_key_pem = utils.dump_privatekey(new_key)
new_crt_pem = cas.renew(
crt_pem=old_crt_pem,
csr_pem=utils.dump_certificate_request(
x509.CertificateSigningRequestBuilder(
).subject_name(
# Note: caucase server ignores this, but cryptography
# requires CSRs to have a subject.
old_crt.subject,
).sign(
private_key=new_key,
algorithm=utils.DEFAULT_DIGEST_CLASS(),
backend=_cryptography_backend,
),
),
)
with open(server_key_path, 'w') as crt_file:
crt_file.write(new_key_pem)
crt_file.write(new_crt_pem)
else:
new_key = utils.generatePrivateKey(key_len)
csr_id = cas.appendCertificateSigningRequest(
csr_pem=utils.dump_certificate_request(
x509.CertificateSigningRequestBuilder(
).subject_name(
x509.Name([
x509.NameAttribute(
oid=x509.oid.NameOID.COMMON_NAME,
value=hostname.decode('ascii'),
),
]),
).add_extension(
x509.KeyUsage(
# pylint: disable=bad-whitespace
digital_signature =True,
content_commitment=False,
key_encipherment =True,
data_encipherment =False,
key_agreement =False,
key_cert_sign =False,
crl_sign =False,
encipher_only =False,
decipher_only =False,
# pylint: enable=bad-whitespace
),
critical=True,
).sign(
private_key=new_key,
algorithm=utils.DEFAULT_DIGEST_CLASS(),
backend=_cryptography_backend,
),
),
override_limits=True,
)
cas.createCertificate(csr_id)
new_crt_pem = cas.getCertificate(csr_id)
new_key_pem = utils.dump_privatekey(new_key)
old_mask = os.umask(077)
try:
with open(server_key_path, 'w') as crt_file:
crt_file.write(new_key_pem)
crt_file.write(new_crt_pem)
finally:
os.umask(old_mask)
ssl_context.load_cert_chain(server_key_path)
if wrap:
https.socket = ssl_context.wrap_socket(
sock=https.socket,
server_side=True,
)
else:
https.socket.context = ssl_context
return utils.load_certificate(
utils.getCert(server_key_path),
cas_certificate_list,
None,
).not_valid_after - threshold_delta
def main(argv=None):
"""
Caucase stand-alone http server.
"""
parser = argparse.ArgumentParser(description='caucased')
parser.add_argument(
'--db',
default='caucase.sqlite',
help='Path to the SQLite database. default: %(default)s',
)
parser.add_argument(
'--server-key',
default='server.key.pem',
metavar='KEY_PATH',
help='Path to the ssl key pair to use for https socket. '
'default: %(default)s',
)
parser.add_argument(
'--netloc',
required=True,
help='<host>[:<port>] of HTTP socket. '
'HTTPS socket netloc will be deduced following caucase rules: if port is '
'80 or not provided, https port will be 443, else it will be port + 1. '
'If not provided, http port will be picked among available ports and '
'https port will be the next port. Also, signed certificates will not '
'contain a CRL distribution point URL. If https port is not available, '
'this program will exit with an aerror status. '
'Note on encoding: only ascii is currently supported. Non-ascii may be '
'provided idna-encoded.',
)
parser.add_argument(
'--threshold',
default=31,
type=float,
help='The remaining certificate validity period, in days, under '
'which a renew is desired. default: %(default)s',
)
parser.add_argument(
'--key-len',
default=2048,
type=int,
metavar='BITLENGTH',
help='Number of bits to use when generating a new private key. '
'default: %(default)s',
)
service_group = parser.add_argument_group(
'CAS options: normal certificates, which are not given any privilege on '
'caucased',
)
user_group = parser.add_argument_group(
'CAU options: special certificates, which are allowed to sign other '
'certificates and can decrypt backups',
)
service_group.add_argument(
'--service-crt-validity',
default=3 * 31,
type=float,
metavar='DAYS',
help='Number of days an issued certificate is valid for. '
'default: %(default)s',
)
user_group.add_argument(
'--user-crt-validity',
default=3 * 31,
type=float,
metavar='DAYS',
help='Number of days an issued certificate is valid for. '
'default: %(default)s',
)
service_group.add_argument(
'--service-max-csr',
default=50,
type=int,
help='Maximum number of pending CSR. Further CSR get refused until '
'an existing ones gets signed or rejected. default: %(default)s',
)
user_group.add_argument(
'--user-max-csr',
default=50,
type=int,
help='Maximum number of pending CSR. Further CSR get refused until '
'an existing ones gets signed or rejected. default: %(default)s',
)
service_group.add_argument(
'--service-auto-approve-count',
default=0,
type=int,
metavar='COUNT',
help='Number service certificates which should be automatically signed on '
'submission, excluding the one needed to serve caucase. '
'default: %(default)s'
)
user_group.add_argument(
'--user-auto-approve-count',
default=1,
type=int,
metavar='COUNT',
help='Number of user certificates which should be automatically signed on '
'submission. default: %(default)s',
)
parser.add_argument(
'--lock-auto-approve-count',
action='store_true',
help='The first time this option is given, --service-auto-approve-count '
'and --user-auto-approve-count values are stored inside caucase database '
'and will not be altered by further invocations. Once the respective '
'certificate issuance counters reach these values, no further '
'certificates will be ever automatically signed.'
)
backup_group = parser.add_argument_group(
'Backup options',
)
backup_group.add_argument(
'--backup-directory',
help='Backup file path template. Backups will be periodically stored in '
'given directory, encrypted with all certificates which are valid at the '
'time of backup generation. Any one of the associated private keys can '
'decypher it. If not set, no backup will be created.',
)
backup_group.add_argument(
'--backup-period',
default=1,
type=float,
help='Number of days between backups. default: %(default)s'
)
backup_group.add_argument(
'--restore-backup',
nargs=4,
metavar=('BACKUP_PATH', 'KEY_PATH', 'CSR_PATH', 'CRT_PATH'),
help='Restore the file at BACKUP_PATH, decyphering it with the key '
'at KEY_PATH, revoking corresponding certificate and issuing a new '
'one in CRT_PATH using the public key in CSR_PATH. '
'If database is not empty, nothing is done. '
'Then process will exit and must be restarted wihtout this option.',
)
args = parser.parse_args(argv)
# pylint: disable=unused-argument
def onTERM(signum, stack):
"""
Sigterm handler
"""
# The main objective of this signal hander is to fix coverage scores:
# without it, it seems hits generated by this process do not get
# accounted for (atexit not called ?). With it, interpreter shutdown
# seems nicer.
raise SystemExit
# pylint: enable=unused-argument
signal.signal(signal.SIGTERM, onTERM)
base_url = u'http://' + args.netloc.decode('ascii')
parsed_base_url = urlparse(base_url)
hostname = parsed_base_url.hostname
http_port = parsed_base_url.port
cau_crt_life_time = args.user_crt_validity
cau_db_kw = {
'table_prefix': 'cau',
'max_csr_amount': args.user_max_csr,
# Effectively disables certificate expiration
'crt_keep_time': cau_crt_life_time,
'crt_read_keep_time': cau_crt_life_time,
'enforce_unique_key_id': True,
}
cau_kw = {
'ca_subject_dict': {
'CN': u'Caucase CAU' + (
u'' if base_url is None else u' at ' + base_url + '/cau'
),
},
'ca_key_size': args.key_len,
'crt_life_time': cau_crt_life_time,
'auto_sign_csr_amount': args.user_auto_approve_count,
'lock_auto_sign_csr_amount': args.lock_auto_approve_count,
}
if args.restore_backup:
(
backup_path,
backup_key_path,
backup_csr_path,
backup_crt_path,
) = args.restore_backup
try:
_, key_pem, _ = utils.getKeyPair(backup_key_path)
except ValueError:
# maybe user extracted their private key ?
key_pem = utils.getKey(backup_key_path)
with open(backup_path) as backup_file:
with open(backup_crt_path, 'a') as new_crt_file:
new_crt_file.write(
UserCertificateAuthority.restoreBackup(
db_class=SQLite3Storage,
db_path=args.db,
read=backup_file.read,
key_pem=key_pem,
csr_pem=utils.getCertRequest(backup_csr_path),
db_kw=cau_db_kw,
kw=cau_kw,
),
)
return
cau = UserCertificateAuthority(
storage=SQLite3Storage(
db_path=args.db,
**cau_db_kw
),
**cau_kw
)
cas = CertificateAuthority(
storage=SQLite3Storage(
db_path=args.db,
table_prefix='cas',
max_csr_amount=args.service_max_csr,
),
ca_subject_dict={
'CN': u'Caucase CAS' + (
u'' if base_url is None else u' at ' + base_url + '/cas'
),
},
crl_base_url=None if base_url is None else base_url + u'/cas/crl',
ca_key_size=args.key_len,
crt_life_time=args.service_crt_validity,
auto_sign_csr_amount=args.service_auto_approve_count,
lock_auto_sign_csr_amount=args.lock_auto_approve_count,
)
application = Application(cau=cau, cas=cas)
http = make_server(
host=hostname,
port=http_port,
app=application,
server_class=ThreadingWSGIServer,
handler_class=CaucaseWSGIRequestHandler,
)
https = make_server(
host=hostname,
port=443 if http_port == 80 else http_port + 1,
app=application,
server_class=ThreadingWSGIServer,
handler_class=CaucaseSSLWSGIRequestHandler,
)
next_deadline = next_ssl_update = updateSSLContext(
https=https,
key_len=args.key_len,
threshold=args.threshold,
server_key_path=args.server_key,
hostname=hostname,
cau=cau,
cas=cas,
wrap=True,
)
if args.backup_directory:
backup_period = datetime.timedelta(args.backup_period, 0)
try:
next_backup = max(
datetime.datetime.utcfromtimestamp(os.stat(x).st_ctime)
for x in glob.iglob(
os.path.join(args.backup_directory, '*' + BACKUP_SUFFIX),
)
) + backup_period
except ValueError:
next_backup = datetime.datetime.utcnow()
next_deadline = min(
next_deadline,
next_backup,
)
else:
next_backup = None
startServerThread(http)
startServerThread(https)
try:
while True:
now = utils.until(next_deadline)
if now >= next_ssl_update:
next_ssl_update = updateSSLContext(
https=https,
key_len=args.key_len,
threshold=args.threshold,
server_key_path=args.server_key,
hostname=hostname,
cau=cau,
cas=cas,
)
if next_backup is None:
next_deadline = next_ssl_update
else:
if now >= next_backup:
tmp_backup_fd, tmp_backup_path = tempfile.mkstemp(
prefix='caucase_backup_',
)
with os.fdopen(tmp_backup_fd, 'w') as backup_file:
result = cau.doBackup(backup_file.write)
if result:
backup_path = os.path.join(
args.backup_directory,
now.strftime('%Y%m%d%H%M%S') + BACKUP_SUFFIX,
)
os.rename(tmp_backup_path, backup_path)
next_backup = now + backup_period
else:
os.unlink(tmp_backup_path)
next_backup = now + datetime.timedelta(0, 3600)
next_deadline = min(
next_ssl_update,
next_backup,
)
except utils.SleepInterrupt:
pass
.ui-table th, .ui-table td {
line-height: 1.5em;
text-align: left;
padding: .4em .5em;
vertical-align: middle;
}
.ui-overlay-a, .ui-page-theme-a, .ui-page-theme-a .ui-panel-wrapper {
background-color: #fff !important;
}
table .ui-table th, table .ui-table td {
vertical-align: middle;
}
.noshadow buton, .noshadow a, .noshadow input, .noshadow select {
-webkit-box-shadow: none !important;
-moz-box-shadow: none !important;
box-shadow: none !important;
}
.ui-error, html .ui-content .ui-error a, .ui-content a.ui-error {
color: red;
font-weight: bold;
}
html body {
overflow-x: hidden;
background: #fbfbfb;
}
.form-signin {
max-width: 330px;
padding: 15px;
margin: 0 auto;
}
.form-signin .form-signin-heading,
.form-signin .checkbox {
margin-bottom: 10px;
}
.form-signin .checkbox {
font-weight: normal;
}
.form-signin .form-control {
position: relative;
height: auto;
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
padding: 10px;
font-size: 16px;
}
.form-signin .form-control:focus {
z-index: 2;
}
.form-signin input[type="email"] {
margin-bottom: -1px;
border-bottom-right-radius: 0;
border-bottom-left-radius: 0;
}
.form-signin input[type="password"] {
margin-bottom: 10px;
border-top-left-radius: 0;
border-top-right-radius: 0;
}
/* Toggle Styles */
#wrapper {
padding-left: 0;
-webkit-transition: all 0.6s ease;
-moz-transition: all 0.6s ease;
-o-transition: all 0.6s ease;
transition: all 0.6s ease;
}
#wrapper.toggled {
padding-left: 200px;
}
#sidebar-wrapper {
z-index: 1000;
position: fixed;
left: 250px;
width: 0;
height: 100%;
margin-left: -250px;
overflow-y: auto;
background-color:#312A25 !Important;
-webkit-transition: all 0.2s ease;
-moz-transition: all 0.2s ease;
-o-transition: all 0.2s ease;
transition: all 0.2s ease;
}
#wrapper.toggled #sidebar-wrapper {
width: 0;
}
#page-content-wrapper {
width: 100%;
position: absolute;
padding: 10px;
}
#wrapper.toggled #page-content-wrapper {
position: absolute;
margin-left:-250px;
}
/* Sidebar Styles */
.nav-side-menu {
overflow: auto;
font-family: verdana;
font-size: 12px;
font-weight: 200;
background-color: #2a2f35; /* #313130 */
position: fixed;
top: 0px;
width: 300px;
height: 100%;
color: #e1ffff;
}
.nav-side-menu .brand {
background-color: #404040;
line-height: 50px;
display: block;
text-align: center;
font-size: 14px;
}
.nav-side-menu .toggle-btn {
display: none;
}
.nav-side-menu ul,
.nav-side-menu li {
list-style: none;
padding: 0px;
margin: 0px;
line-height: 35px;
cursor: pointer;
/*
.collapsed{
.arrow:before{
font-family: FontAwesome;
content: "\f053";
display: inline-block;
padding-left:10px;
padding-right: 10px;
vertical-align: middle;
float:right;
}
}
*/
}
.nav-side-menu ul :not(collapsed) .arrow:before,
.nav-side-menu li :not(collapsed) .arrow:before {
font-family: FontAwesome;
content: "\f078";
display: inline-block;
padding-left: 10px;
padding-right: 10px;
vertical-align: middle;
float: right;
}
.nav-side-menu ul .active,
.nav-side-menu li .active {
border-left: 3px solid #d19b3d;
background-color: #4f5b69;
}
.nav-side-menu ul .sub-menu li.active,
.nav-side-menu li .sub-menu li.active {
color: #d19b3d;
}
.nav-side-menu ul .sub-menu li.active a,
.nav-side-menu li .sub-menu li.active a {
color: #d19b3d;
}
.nav-side-menu ul .sub-menu li,
.nav-side-menu li .sub-menu li {
background-color: #181c20;
border: none;
line-height: 28px;
border-bottom: 1px solid #23282e;
margin-left: 0px;
}
.nav-side-menu ul .sub-menu li:hover,
.nav-side-menu li .sub-menu li:hover {
background-color: #020203;
}
.nav-side-menu ul .sub-menu li:before,
.nav-side-menu li .sub-menu li:before {
font-family: FontAwesome;
content: "\f105";
display: inline-block;
padding-left: 10px;
padding-right: 10px;
vertical-align: middle;
}
.nav-side-menu li {
padding-left: 0px;
border-left: 3px solid #2e353d;
border-bottom: 1px solid #23282e;
}
.nav-side-menu li a {
text-decoration: none;
color: #e1ffff;
display: block;
}
.nav-side-menu li a i {
padding-left: 10px;
width: 20px;
padding-right: 25px;
font-size: 18px;
}
.nav-side-menu li:hover {
border-left: 3px solid #d19b3d;
background-color: #4f5b69;
-webkit-transition: all 1s ease;
-moz-transition: all 1s ease;
-o-transition: all 1s ease;
-ms-transition: all 1s ease;
transition: all 1s ease;
}
@media (max-width: 767px) {
.nav-side-menu {
position: relative;
width: 100%;
margin-bottom: 10px;
}
.nav-side-menu .toggle-btn {
display: block;
cursor: pointer;
position: absolute;
right: 10px;
top: 10px;
z-index: 10 !important;
padding: 3px;
background-color: #ffffff;
color: #000;
width: 40px;
text-align: center;
}
.brand {
text-align: left !important;
font-size: 22px;
padding-left: 20px;
line-height: 50px !important;
}
}
@media (min-width: 767px) {
.nav-side-menu .menu-list .menu-content {
display: block;
}
#main {
width:calc(100% - 300px);
float: right;
}
}
body {
margin: 0px;
padding: 0px;
}
pre {
max-height: 600px;
}
.col-centered {
float: none;
margin: 0 auto;
}
.clickable{
cursor: pointer;
}
.table .panel-heading div {
margin-top: -18px;
font-size: 15px;
}
.table .panel-heading div span{
margin-left:5px;
}
.table .panel-body{
display: none;
}
.container .table>tbody>tr>td, .table>tbody>tr>th, .table>tfoot>tr>td, .table>tfoot>tr>th, .table>thead>tr>td, .table>thead>tr>th {
vertical-align: middle;
}
.margin-top-40 {
margin-top:40px;
}
.margin-lr-20 {
margin: 0 20px;
}
.flashes-messages div:first-child {
margin-top: 30px;
}
/* Dashboard boxes */
.dash-panel {
text-align: center;
padding: 1px 0;
}
html body a:hover > .dash-panel h4 {
text-decoration: none;
}
.dash-panel:hover {
background-color: #e6e6e6;
border-color: #adadad;
cursor: pointer;
}
.dash {
position: relative;
text-align: center;
width: 120px;
height: 55px;
margin: 10px auto 10px auto;
}
#dash-blue .number {
color: #30a5ff;
}
#dash-orange .number {
color: #ffb53e;
}
#dash-teal .number {
color: #1ebfae;
}
#dash-red .number {
color: #ef4040;
}
#dash-darkred .number {
color: #bd0849;
}
.dash .number {
display: block;
position: absolute;
font-size: 46px;
width: 120px;
}
.alert-error {
color: #a94442;
background-color: #f2dede;
border-color: #ebccd1;
}
$( document ).ready(function() {
$("#menu-toggle").click(function(e) {
e.preventDefault();
$("#wrapper").toggleClass("toggled");
});
});
(function(){
'use strict';
var $ = jQuery;
$.fn.extend({
filterTable: function(){
return this.each(function(){
$(this).on('keyup', function(e){
$('.filterTable_no_results').remove();
var $this = $(this),
search = $this.val().toLowerCase(),
target = $this.attr('data-filters'),
$target = $(target),
$rows = $target.find('tbody tr');
if(search === '') {
$rows.show();
} else {
$rows.each(function(){
var $this = $(this);
$this.text().toLowerCase().indexOf(search) === -1 ? $this.hide() : $this.show();
});
if($target.find('tbody tr:visible').size() === 0) {
var col_count = $target.find('tr').first().find('td').size();
var no_results = $('<tr class="filterTable_no_results"><td colspan="'+col_count+'">No results found</td></tr>');
$target.find('tbody').append(no_results);
}
}
});
});
}
});
$('[data-action="filter"]').filterTable();
})(jQuery);
$(function(){
// attach table filter plugin to inputs
$('[data-action="filter"]').filterTable();
$('.container').on('click', '.panel-heading span.filter', function(e){
var $this = $(this),
$panel = $this.parents('.panel');
$panel.find('.panel-body').slideToggle();
if($this.css('display') != 'none') {
$panel.find('.panel-body input').focus();
}
});
$('[data-toggle="tooltip"]').tooltip();
});
\ No newline at end of file
......@@ -15,591 +15,546 @@
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
"""
Caucase - Certificate Authority for Users, Certificate Authority for SErvices
"""
from __future__ import absolute_import
from random import getrandbits
import os
import errno
import uuid
import hashlib
from datetime import datetime, timedelta
from OpenSSL import crypto
from caucase import db
from caucase import utils
from caucase.exceptions import (NoStorage, NotFound, Found, ExpiredCertificate)
from flask_user import UserMixin
STATUS_VALIDATED = 'validated'
STATUS_REVOKED = 'invalidated'
STATUS_REJECTED = 'rejected'
STATUS_PENDING = 'pending'
class Storage(object):
def __init__(self, db_instance, max_csr_amount=None,
crt_keep_time=None, csr_keep_time=None):
self.db = db_instance
# initialise tables
self.db.create_all()
# store some config in storage
if max_csr_amount:
self.__setConfig('max-csr-amount', max_csr_amount)
if crt_keep_time is not None:
self.__setConfig('crt-keep-time', crt_keep_time) # 0 mean always keep in storage
if csr_keep_time is not None:
self.__setConfig('csr-keep-time', csr_keep_time) # 0 mean always keep non pending csr in storage
def _getConfig(self, key):
return Config.query.filter(Config.key == key).first()
def __setConfig(self, key, value):
"""
Add new config to storage
"""
entry = self._getConfig(key)
if not entry:
entry = Config(key=key, value='%s' % value)
self.db.session.add(entry)
else:
# update value
entry.value = value
self.db.session.commit()
import sqlite3
from threading import local
from time import time
from .exceptions import NoStorage, NotFound, Found
__all__ = ('SQLite3Storage', )
DAY_IN_SECONDS = 60 * 60 * 24
def getConfig(self, key, default=None):
class SQLite3Storage(local):
"""
CA data storage.
Every cryptographic type this class deals with must be PEM-encoded.
"""
def __init__(
self,
db_path,
table_prefix,
max_csr_amount=50,
crt_keep_time=1,
crt_read_keep_time=0.05, # About 1 hour
enforce_unique_key_id=False,
):
"""
Return a config value or default
db_path (str)
SQLite connection string.
table_prefix (str)
Name to use as a prefix for all tables managed by this storage adapter.
Allows sharing the database, although it should only be within the same
caucase process for access permission reasons.
max_csr_amount (int)
Maximum number of allowed pending certificate signing requests.
To prevent flood.
crt_keep_time (float)
Time to keep signed certificates for, in days.
crt_read_keep_time (float)
Time to keep CRT content for after it was first read, in days.
Allows requester to fail retrieving the certificate by tolerating
retries.
enforce_unique_key_id (bool)
When true, certificate requests cannot be appended if there is already
and known entry for the same private key.
Note: this only makes sense if crt_keep_time and crt_read_keep_time are
set at least to the certificate life span.
Useful for backups, to ensure the certificate to revoke can be uniquely
identified from the key used to decrypt the backup archive.
"""
entry = self._getConfig(key)
if not entry:
return default
return entry.value
super(SQLite3Storage, self).__init__()
self._db = db = sqlite3.connect(db_path)
self._table_prefix = table_prefix
db.row_factory = sqlite3.Row
self._max_csr_amount = max_csr_amount
self._crt_keep_time = crt_keep_time * DAY_IN_SECONDS
self._crt_read_keep_time = crt_read_keep_time * DAY_IN_SECONDS
with db:
# Note about revoked.serial: certificate serials exceed the 63 bits
# sqlite can accept as integers, so store these as text. Use a trivial
# string serialisation: not very space efficient, but this should not be
# a limiting issue for our use-cases anyway.
db.cursor().executescript('''
CREATE TABLE IF NOT EXISTS %(prefix)sca (
expiration_date INTEGER,
key TEXT,
crt TEXT
);
CREATE TABLE IF NOT EXISTS %(prefix)scrt (
id INTEGER PRIMARY KEY,
key_id TEXT %(key_id_constraint)s,
expiration_date INTEGER,
csr TEXT,
crt TEXT
);
CREATE TABLE IF NOT EXISTS %(prefix)srevoked (
serial TEXT PRIMARY KEY,
revocation_date INTEGER,
expiration_date INTEGER
);
CREATE TABLE IF NOT EXISTS %(prefix)scrl (
expiration_date INTEGER,
crl TEXT
);
CREATE TABLE IF NOT EXISTS %(prefix)scounter (
name TEXT PRIMARY KEY,
value INTEGER
);
CREATE TABLE IF NOT EXISTS %(prefix)sconfig_once (
name TEXT PRIMARY KEY,
value TEXT
)
''' % {
'prefix': table_prefix,
'key_id_constraint': 'UNIQUE' if enforce_unique_key_id else '',
})
def _getMaxCsrCount(self):
return int(self.getConfig('max-csr-amount', 50))
def _incrementCounter(self, name, increment=1, initial=0):
"""
Increment counter with <name> by <increment> and return resulting value.
If <name> is not found, it is created with <initial>, and then incremented.
Does not commit.
"""
row = self._executeSingleRow(
'SELECT value FROM %scounter WHERE name = ? LIMIT 2' % (
self._table_prefix,
),
(name, ),
)
if row is None:
value = initial
else:
value = row['value']
value += increment
self._db.cursor().execute(
'INSERT OR REPLACE INTO %scounter (name, value) VALUES (?, ?)' % (
self._table_prefix,
),
(name, value),
)
return value
def getCAKeyPairList(self):
def _executeSingleRow(self, sql, parameters=()):
"""
Return the chronologically sorted (oldest in [0], newest in [-1]) certificate authority
key pairs.
Execute <sql>, raise if it produces more than 1 row, and return it.
"""
item_list = CAKeypair.query.filter(
CAKeypair.active == True
).order_by(
CAKeypair.creation_date.asc()
).all()
result_list = self._db.cursor().execute(sql, parameters).fetchall()
if result_list:
result, = result_list
return result
if not item_list:
return []
def getConfigOnce(self, name, default):
"""
Retrieve the value of <name> from config-once list, or <default> if not
stored.
"""
with self._db:
result = self._executeSingleRow(
'SELECT value FROM %sconfig_once WHERE name = ?' % (
self._table_prefix,
),
(name, ),
)
if result is None:
return default
return result['value']
keypair_list = []
for keypair in item_list:
keypair_list.append({
'crt': crypto.load_certificate(crypto.FILETYPE_PEM, keypair.certificate),
'key': crypto.load_privatekey(crypto.FILETYPE_PEM, keypair.key)
})
def setConfigOnce(self, name, value):
"""
Store <value> as <name> in config-once list, if it was not already stored.
If it was already stored, do nothing.
"""
try:
with self._db as db:
db.cursor().execute(
'INSERT INTO %sconfig_once (name, value) VALUES (?, ?)' % (
self._table_prefix,
),
(name, value),
)
except sqlite3.IntegrityError:
pass
return keypair_list
def getCAKeyPairList(self):
"""
Return the chronologically sorted (oldest in [0], newest in [-1])
certificate authority key pairs.
"""
with self._db as db:
c = db.cursor()
c.execute(
'DELETE FROM %sca WHERE expiration_date < ?' % (
self._table_prefix,
),
(time(), ),
)
return [
{
'crt_pem': x['crt'].encode('ascii'),
'key_pem': x['key'].encode('ascii'),
}
for x in db.cursor().execute(
'SELECT key, crt FROM %sca ORDER BY expiration_date ASC' % (
self._table_prefix,
),
).fetchall()
]
def storeCAKeyPair(self, key_pair):
def appendCAKeyPair(self, expiration_timestamp, key_pair):
"""
Store a certificate authority key pair.
expiration_timestamp (int)
Unix GMT timestamp of CA certificate "valid until" date.
key_pair (dict with 'key' and 'crt' items)
CA key pair to store, as bytes.
"""
serial = utils.getSerialToInt(key_pair['crt'])
crt_string = crypto.dump_certificate(crypto.FILETYPE_PEM, key_pair['crt'])
key_string = crypto.dump_privatekey(crypto.FILETYPE_PEM, key_pair['key'])
# check that keypair is not stored
keypair = CAKeypair.query.filter(
CAKeypair.active == True
).filter(
CAKeypair.serial == serial
).first()
if keypair:
raise Found('Another CA certificate exists with serial %r' % (serial, ))
saved_pair = CAKeypair(
serial=serial,
common_name=key_pair['crt'].get_subject().CN,
expire_after=datetime.strptime(
key_pair['crt'].get_notAfter(), '%Y%m%d%H%M%SZ'
),
start_before=datetime.strptime(
key_pair['crt'].get_notBefore(), '%Y%m%d%H%M%SZ'
),
key=key_string,
certificate=crt_string,
active=True,
creation_date=datetime.utcnow()
with self._db as db:
db.cursor().execute(
'INSERT INTO %sca (expiration_date, key, crt) VALUES (?, ?, ?)' % (
self._table_prefix,
),
(
expiration_timestamp,
key_pair['key_pem'],
key_pair['crt_pem'],
),
)
self.db.session.add(saved_pair)
self.db.session.commit()
def storeCertificateSigningRequest(self, csr):
def appendCertificateSigningRequest(self, csr_pem, key_id, override_limits=False):
"""
Store acertificate signing request and generate a unique ID for it.
Note: ID uniqueness is only guaranteed among pending CSR, and may be reused
after the original CSR has been discarded (by being rejected or signed).
"""
csr_amount = self.countPendingCertificateSiningRequest()
if csr_amount >= self._getMaxCsrCount():
raise NoStorage('Too many pending CSRs')
content = crypto.dump_certificate_request(crypto.FILETYPE_PEM, csr)
checksum = hashlib.md5(content).hexdigest()
check_csr = CertificateRequest.query.filter(
CertificateRequest.status == STATUS_PENDING
).filter(
CertificateRequest.checksum == checksum
).first()
if check_csr:
# this only prevent client loop sending the same csr until csr_amount is reached
return check_csr.csr_id
key = str(uuid.uuid1().hex)
csr_id = '%s.csr.pem' % key
crt_id = '%s.crt.pem' % key
req = CertificateRequest(
content=content,
creation_date=datetime.utcnow(),
common_name=csr.get_subject().CN,
checksum=checksum,
csr_id=csr_id,
crt_id=crt_id)
request_amount = self._getConfig('csr-requested-amount')
if not request_amount:
request_amount = Config(key='csr-requested-amount', value='1')
self.db.session.add(request_amount)
else:
request_amount.value = '%s' % (int(request_amount.value) + 1,)
self.db.session.add(req)
self.db.session.commit()
return csr_id
def deletePendingCertificateRequest(self, csr_id):
csr = CertificateRequest.query.filter(
CertificateRequest.status == STATUS_PENDING
).filter(
CertificateRequest.csr_id == csr_id
).first()
if csr:
self.db.session.delete(csr)
self.db.session.commit()
else:
raise NotFound('No pending CSR with id %r' % (csr_id, ))
def getPendingCertificateRequest(self, csr_id):
csr = CertificateRequest.query.filter(
CertificateRequest.status == STATUS_PENDING
).filter(
CertificateRequest.csr_id == csr_id
).first()
if csr:
return csr.content
raise NotFound('No pending CSR with id %r' % (csr_id, ))
def getPendingCertificateRequestList(self, limit=0, with_data=False):
"""
Return list of all CSR
"""
data_list = []
index = 1
query = CertificateRequest.query.filter(
CertificateRequest.status == STATUS_PENDING
)
if limit > 0:
query.limit(limit)
csr_list = query.all()
for request_csr in csr_list:
csr = {
'index': index,
'csr_id': request_csr.csr_id,
'crt_id': request_csr.crt_id,
'common_name': request_csr.common_name,
'creation_date': request_csr.creation_date
}
if with_data:
certificate['content'] = request_csr.content
data_list.append(csr)
index += 1
return data_list
with self._db as db:
known_csr = self._executeSingleRow(
'SELECT id FROM %scrt WHERE csr = ? LIMIT 2' % (
self._table_prefix,
),
(csr_pem, ),
)
if known_csr is not None:
return known_csr['id'], None
if override_limits:
# Ignore max pending count
# Do not increment the number of auto-signed certificates, but do not
# automatically sign either.
requested_count = None
else:
if self._executeSingleRow(
'SELECT COUNT(*) FROM %scrt WHERE crt IS NULL' % (
self._table_prefix,
)
)[0] >= self._max_csr_amount:
raise NoStorage
requested_count = self._incrementCounter('received_csr')
csr_id = getrandbits(63)
c = db.cursor()
c.execute(
'INSERT INTO %scrt (id, key_id, csr) VALUES (?, ?, ?)' % (
self._table_prefix,
),
(
csr_id,
key_id,
csr_pem,
),
)
c.execute(
'DELETE FROM %scrt WHERE expiration_date < ?' % (
self._table_prefix,
),
(time(), ),
)
return csr_id, requested_count
def storeCertificate(self, csr_id, crt):
def deletePendingCertificateSigningRequest(self, csr_id):
"""
Store certificate as crt_id. crt is a certificate PEM object.
"""
csr = csr = CertificateRequest.query.filter(
CertificateRequest.status == STATUS_PENDING
).filter(
CertificateRequest.csr_id == csr_id
).first()
if not csr:
raise NotFound('No pending CSR with id %r' % (csr_id, ))
cert = Certificate.query.filter(
Certificate.status == STATUS_VALIDATED
).filter(
Certificate.crt_id == csr.crt_id
).first()
if cert:
raise Found('CRT already exists')
cert_db = Certificate(
crt_id=csr.crt_id,
serial=utils.getSerialToInt(crt),
common_name=crt.get_subject().CN,
expire_after=datetime.strptime(crt.get_notAfter(), '%Y%m%d%H%M%SZ'),
start_before=datetime.strptime(crt.get_notBefore(), '%Y%m%d%H%M%SZ'),
creation_date=datetime.utcnow(),
content=crypto.dump_certificate(crypto.FILETYPE_PEM, crt)
)
# Change Csr status as 'validated', so it can be trashed
csr.status = STATUS_VALIDATED
self.db.session.add(cert_db)
self.db.session.commit()
return csr.crt_id
def getCertificateFromSerial(self, serial):
cert = Certificate.query.filter(
Certificate.status == STATUS_VALIDATED
).filter(
Certificate.serial == '%s' % serial
).first()
Forget about a pending CSR. Does nothing if the CSR was already signed
(it will be automatically garbage-collected later).
Raises NotFound if there is no matching CSR.
"""
with self._db as db:
c = db.cursor()
c.execute(
'DELETE FROM %scrt WHERE id = ? AND crt IS NULL' % (
self._table_prefix,
),
(csr_id, ),
)
if c.rowcount == 1:
return
raise NotFound
if cert:
return cert
def getCertificateSigningRequest(self, csr_id):
"""
Retrieve a PEM-encoded certificate signing request.
raise NotFound('No certficate with serial %r' % (serial, ))
# schedule certificate removal
csr_id (int)
Desired CSR id, as given when the CSR was stored.
def getCertificate(self, crt_id):
cert = Certificate.query.filter(
Certificate.status == STATUS_VALIDATED
).filter(
Certificate.crt_id == crt_id
).first()
if cert and cert.content:
# if content is emtpy, maybe the certificate content was stripped ?
return cert.content
raise NotFound('No certficate with id %r' % (crt_id, ))
# schedule certificate removal
def getSignedCertificateList(self, limit=0, with_data=False):
data_list = []
index = 1
query = Certificate.query.filter(
Certificate.status == STATUS_VALIDATED
)
if limit > 0:
query.limit(limit)
signed_cert_list = query.all()
for signed_cert in signed_cert_list:
certificate = {
'index': index,
'serial': signed_cert.serial,
'crt_id': signed_cert.crt_id,
'common_name': signed_cert.common_name,
'expire_after': signed_cert.expire_after,
'start_before': signed_cert.start_before,
}
if with_data:
certificate['content'] = signed_cert.content
data_list.append(certificate)
index += 1
return data_list
def revokeCertificate(self, serial=None, crt_id=None, reason=''):
"""
Add serial to the list of revoked certificates.
Associated certificate must expire at (or before) not_after_date, so
revocation can be pruned.
serial or crt_id should be send to get the certificate. If both are set,
serial is used.
"""
if serial is None and crt_id is None:
raise ValueError("serial or crt_id are not set to revokeCertificate.")
query = Certificate.query.filter(Certificate.status == STATUS_VALIDATED)
if serial:
query = query.filter(Certificate.serial == serial)
else:
query = query.filter(Certificate.crt_id == crt_id)
Raises NotFound if there is no matching CSR.
"""
with self._db:
result = self._executeSingleRow(
'SELECT csr FROM %scrt WHERE id = ?' % (
self._table_prefix,
),
(csr_id, ),
)
if result is None:
raise NotFound
return result['csr'].encode('ascii')
cert = query.first()
def getCertificateSigningRequestList(self):
"""
Return the list of all pending CSRs.
if not cert:
raise NotFound('No certficate with serial or id %r found!' % (
serial or crt_id, ))
Ignores any CSR for which a certificate was issued.
"""
with self._db as db:
return [
{
'id': x['id'],
'csr': x['csr'].encode('ascii'),
}
for x in db.cursor().execute(
'SELECT id, csr FROM %scrt WHERE crt IS NULL' % (
self._table_prefix,
),
).fetchall()
]
expire_in = cert.expire_after - datetime.utcnow()
if expire_in.days < 0:
raise ExpiredCertificate("Certificate with serial %r has expired" \
" since %r day(s)." % (serial, -1*expire_in.days))
def storeCertificate(self, csr_id, crt):
"""
Store certificate for pre-existing CSR.
revoke = Revocation(
serial=cert.serial,
creation_date=datetime.utcnow(),
reason=reason,
crt_expire_after=cert.expire_after
Raises NotFound if there is no matching CSR, or if a certificate was
already stored.
"""
with self._db as db:
c = db.cursor()
c.execute(
'UPDATE %scrt SET crt=?, expiration_date = ? '
'WHERE id = ? AND crt IS NULL' % (
self._table_prefix,
),
(
crt,
int(time() + self._crt_keep_time),
csr_id,
),
)
# Set latest CRL as expired, it will be regenerated
crl = CertificateRevocationList.query.filter(
CertificateRevocationList.active == True
).first()
if crl:
crl.active = False
# this certificate is not valid anymore
cert.status = STATUS_REVOKED
self.db.session.add(revoke)
self.db.session.commit()
if c.rowcount == 0:
raise NotFound
def getCertificateRevocationList(self):
"""
Get Certificate Rovocation List of None if there is no valid CRL
def getCertificate(self, crt_id):
"""
last_revocation = CertificateRevocationList.query.order_by(
CertificateRevocationList.id.desc()
).first()
if last_revocation and last_revocation.active:
if (last_revocation.crl_expire_after - datetime.utcnow()).days >= 0:
return last_revocation.content
return None
Retrieve a PEM-encoded certificate.
def getNextCRLVersionNumber(self):
last_revocation = CertificateRevocationList.query.order_by(
CertificateRevocationList.id.desc()
).first()
if last_revocation:
return last_revocation.id + 1
else:
return 1
crt_id (int)
Desired certificate id, which is the same as corresponding CSR's id.
def storeCertificateRevocationList(self, crl, expiration_date):
Raises NotFound if there is no matching CRT or if no certificate was issued
for it.
"""
Store Certificate Revocation List, return stored crl string
XXX - send expiration_date because crypto.crl has no method to read this from crl object
with self._db as db:
row = self._executeSingleRow(
'SELECT crt, expiration_date FROM %scrt '
'WHERE id = ? AND crt IS NOT NULL' % (
self._table_prefix,
),
(crt_id, ),
)
if row is None:
raise NotFound
new_expiration_date = int(time() + self._crt_read_keep_time)
if row['expiration_date'] > new_expiration_date:
db.cursor().execute(
'UPDATE %scrt SET expiration_date = ? WHERE id = ?' % (
self._table_prefix,
),
(
new_expiration_date,
crt_id,
)
)
return row['crt'].encode('ascii')
def getCertificateByKeyIdentifier(self, key_id):
"""
# Fetch cached CRL (or re-generate and store if not cached).
dumped_crl = crypto.dump_crl(crypto.FILETYPE_PEM, crl)
Return the certificate corresponding to given key_id.
revocation_list = CertificateRevocationList(
creation_date=datetime.utcnow(),
crl_expire_after=expiration_date,
content=dumped_crl,
active=True
Raises NotFound if there is no matching CRT or if no certificate was issued
for it.
"""
with self._db:
row = self._executeSingleRow(
'SELECT crt FROM %scrt WHERE key_id = ? AND crt IS NOT NULL' % (
self._table_prefix,
),
(key_id, ),
)
self.db.session.add(revocation_list)
self.db.session.commit()
return dumped_crl
if row is None:
raise NotFound
return row['crt'].encode('ascii')
def getRevocationList(self):
def iterCertificates(self):
"""
Get the list of all revoked certificate which are not expired
Iterator over stored certificates.
"""
return Revocation.query.filter(
Revocation.crt_expire_after >= datetime.utcnow()
).all()
def getCertificateSigningRequestAmount(self):
with self._db as db:
c = db.cursor()
c.execute('SELECT crt FROM %scrt WHERE crt IS NOT NULL' % (
self._table_prefix,
))
while True:
row = c.fetchone()
if row is None:
break
yield row['crt'].encode('ascii')
def revoke(self, serial, expiration_date):
"""
Return number of CSR which was requested until now
Add given certificate serial to the list of revoked certificates.
Flushes any current CRL.
serial (int)
Serial of the certificate to revoke.
expiration_date (int)
Unix timestamp at which the certificate expires, allowing to remove this
entry from the CRL.
"""
return int(self.getConfig('csr-requested-amount', 0))
def countValidatedCertificate(self):
return Certificate.query.filter(
Certificate.status == STATUS_VALIDATED
).count()
def countPendingCertificateSiningRequest(self):
return CertificateRequest.query.filter(
CertificateRequest.status == STATUS_PENDING
).count()
def countRevokedCertificate(self):
return Certificate.query.filter(
Certificate.status == STATUS_REVOKED
).count()
with self._db as db:
c = db.cursor()
c.execute('DELETE FROM %scrl' % (
self._table_prefix,
))
try:
c.execute(
'INSERT INTO %srevoked '
'(serial, revocation_date, expiration_date) '
'VALUES (?, ?, ?)' % (
self._table_prefix,
),
(
str(serial),
int(time()),
expiration_date,
)
)
except sqlite3.IntegrityError:
raise Found
def countCertificateRevocation(self):
return Revocation.query.count()
def getCertificateRevocationList(self):
"""
Get PEM-encoded current Certificate Revocation List.
Returns None if there is no CRL.
"""
with self._db:
row = self._executeSingleRow(
'SELECT crl FROM %scrl '
'WHERE expiration_date > ? ORDER BY expiration_date DESC LIMIT 1' % (
self._table_prefix,
),
(time(), )
)
if row is not None:
return row['crl'].encode('ascii')
def housekeep(self):
def getNextCertificateRevocationListNumber(self):
"""
Remove outdated certificates (because they were retrieved long ago),
ca certificates (because they exceeded their "not valid after" date),
revocation of anway-expired certificates.
Get next CRL sequence number.
"""
crt_keep_time = int(self.getConfig('crt-keep-time', 0))
csr_keep_time = int(self.getConfig('csr-keep-time', 0))
expired_keypair_list = CAKeypair.query.filter(
CAKeypair.expire_after < datetime.utcnow()
).all()
for key_pair in expired_keypair_list:
# Desactivate this ca certificate
key_pair.active = False
return self._incrementCounter('crl_number')
# wipe certificate content
if crt_keep_time > 0:
check_date = datetime.utcnow() - timedelta(0, crt_keep_time)
cert_list = Certificate.query.filter(
Certificate.creation_date <= check_date
)
for cert in cert_list:
# clear x509 certificate information
cert.content = ""
# delete certificate request
if csr_keep_time > 0:
check_date = datetime.utcnow() - timedelta(0, csr_keep_time)
csr_list = CertificateRequest.query.filter(
CertificateRequest.status != STATUS_PENDING
).filter(
CertificateRequest.creation_date <= check_date
)
for csr in csr_list:
self.db.session.delete(csr)
# delete all expired Certificate Rovocation
revocation_list = Revocation.query.filter(
Revocation.crt_expire_after < datetime.utcnow()
).all()
for revocation in revocation_list:
self.db.session.delete(revocation)
# Delete all expired Certificate Rovocation List (CRL)
crl_list = CertificateRevocationList.query.filter(
CertificateRevocationList.crl_expire_after < datetime.utcnow()
).all()
for crl in crl_list:
self.db.session.delete(crl)
self.db.session.commit()
def findOrCreateUser(self, first_name, last_name, email, username, hash_password):
""" Find existing user or create new user """
user = User.query.filter(User.username == username).first()
if not user:
user = User(email=email,
first_name=first_name,
last_name=last_name,
username=username,
password=hash_password,
active=True,
confirmed_at=datetime.utcnow()
def storeCertificateRevocationList(self, crl, expiration_date):
"""
Store Certificate Revocation List.
"""
with self._db as db:
c = db.cursor()
c.execute('DELETE FROM %scrl' % (
self._table_prefix,
))
c.execute(
'INSERT INTO %scrl (expiration_date, crl) VALUES (?, ?)' % (
self._table_prefix,
),
(
int(expiration_date),
crl,
),
)
db.session.add(user)
db.session.commit()
return user
def findUser(self, username):
return User.query.filter(User.username == username).first()
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
def getRevocationList(self):
"""
Get the list of all revoked certificates.
# User authentication information
username = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
Returns a list of dicts, each containing:
- revocation_date (int)
Unix timestamp of certificate revocation.
- serial (int)
Revoked certificate's serial.
"""
with self._db as db:
c = db.cursor()
c.execute(
'DELETE FROM %srevoked WHERE expiration_date < ?' % (
self._table_prefix,
),
(time(), ),
)
return [
{
'revocation_date': int(x['revocation_date']),
'serial': int(x['serial']),
}
for x in c.execute(
'SELECT revocation_date, serial FROM %srevoked' % (
self._table_prefix,
),
)
]
# User email information
email = db.Column(db.String(255), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
def dumpIterator(self):
"""
Backs the *entire* dabase up. This is not limited to tables managed by this
class (so not limited to table_prefix).
"""
for statement in self._db.iterdump():
yield statement.encode('utf-8') + '\0'
# User information
active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0')
first_name = db.Column(db.String(100), nullable=False, server_default='')
last_name = db.Column(db.String(100), nullable=False, server_default='')
@staticmethod
def restore(db_path, restorator):
"""
Restores a dump which is the concatenated output of dumpIterator.
Should not be called directly, but via
ca.CertificateAuthority.restoreBackup .
class Config(db.Model):
"""
This table store some configs and information
"""
__tablename__ = 'config'
key = db.Column(db.String(50), primary_key=True)
value = db.Column(db.Text)
db_path (str)
Path to the SQLite database to produce. Must not exist.
class CAKeypair(db.Model):
"""
This table is used ca certificate key pair
"""
__tablename__ = 'ca_keypair'
id = db.Column(db.Integer, primary_key=True)
serial = db.Column(db.String(50), unique=True)
expire_after = db.Column(db.DateTime)
start_before = db.Column(db.DateTime)
common_name = db.Column(db.String(50), unique=False)
active = db.Column(db.Boolean(), nullable=False, server_default='1')
certificate = db.Column(db.Text)
key = db.Column(db.Text)
creation_date = db.Column(db.DateTime)
class CertificateRequest(db.Model):
"""
This table is used to store certificate signature request
"""
__tablename__ = 'csr'
id = db.Column(db.Integer, primary_key=True)
csr_id=db.Column(db.String(80), unique=True)
crt_id = db.Column(db.String(80), unique=True)
common_name = db.Column(db.String(50), unique=False)
content = db.Column(db.Text)
creation_date = db.Column(db.DateTime)
status = db.Column(db.String(20), unique=False, server_default=STATUS_PENDING)
# checksum prevent to store twice the same csr
checksum = db.Column(db.String(50))
class Certificate(db.Model):
"""
This table is used to store some informations about certificate
"""
__tablename__ = 'certificate'
id = db.Column(db.Integer, primary_key=True)
crt_id = db.Column(db.String(80), unique=True)
serial = db.Column(db.String(50), unique=True)
common_name = db.Column(db.String(50), unique=False)
expire_after = db.Column(db.DateTime)
start_before = db.Column(db.DateTime)
creation_date = db.Column(db.DateTime)
# status = validated or revoked
status = db.Column(db.String(20), unique=False, server_default=STATUS_VALIDATED)
content = db.Column(db.Text)
class Revocation(db.Model):
"""
This table store certificate revocation request from users
"""
__tablename__ = 'revoked'
id = db.Column(db.Integer, primary_key=True)
serial = db.Column(db.String(50), unique=False)
crt_expire_after = db.Column(db.DateTime)
reason = db.Column(db.String(200), unique=False)
creation_date = db.Column(db.DateTime)
class CertificateRevocationList(db.Model):
"""
This table store certificate revocation list content
"""
__tablename__ = 'crl'
id = db.Column(db.Integer, primary_key=True)
active = db.Column(db.Boolean(), nullable=False, server_default='1')
creation_date = db.Column(db.DateTime)
crl_expire_after = db.Column(db.DateTime)
content = db.Column(db.Text)
read (callabla taking an integer as argument)
Must return this many bytes, or an empty string if there is no input
left.
"""
buf = ''
if os.path.exists(db_path):
raise ValueError('%r exists, not restoring.' % (db_path, ))
c = sqlite3.connect(db_path, isolation_level=None).cursor()
for chunk in restorator:
statement_list = (buf + chunk).split('\0')
buf = statement_list.pop()
for statement in statement_list:
c.execute((statement).decode('utf-8'))
if buf:
raise ValueError('Short read, backup truncated ?')
{% extends "layout.html" %}
{% block content %}
<form class="form-signin" method="POST" action="/admin/setpassword">
<h2 class="form-signin-heading" style="margin-bottom: 30px">Set admin password</h2>
<label for="pw" class="sr-only">Password</label>
<input type="inputPassword" name="password" id="pw" class="form-control" placeholder="password" required autofocus>
<label for="pw2" class="sr-only">Confirm Password:</label>
<input type="inputPassword" name="password2" id="pw2" class="form-control" placeholder="Confirm password" required autofocus>
<br/>
<button class="btn btn-lg btn-primary btn-block" type="submit">configure</button>
</form>
{% endblock %}
{% extends "layout.html" %}
{% block pre_content %}
<div class="row">
<div class="col-sm-7 col-md-6 col-lg-5 col-centered">
{% endblock %}
{% block post_content %}
</div>
</div>
{% endblock %}
\ No newline at end of file
{% extends 'flask_user/flask_user_base.html' %}
\ No newline at end of file
{% extends 'flask_user/flask_user_base.html' %}
\ No newline at end of file
<!-- Placed at the end of the document so the pages load faster -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa" crossorigin="anonymous"></script>
<script type=application/javascript src="{{ url_for('static', filename='scripts/index.js') }}"></script>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Certificate Authority web</title>
<link rel=stylesheet type=text/css href="{{ url_for('static', filename='css/styles.css') }}">
<link href="//netdna.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.min.css" rel="stylesheet" type="text/css" />
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
{% extends "layout.html" %}
{% block content %}
<div class="page-header">
<h1>Certificate authority<small> Signed Certificates</small></h1>
</div>
<div class="row">
<div class="col-md-12">
<div class="panel panel-success margin-top-40 table">
<div class="panel-heading">
<h3 class="panel-title">List of signed Certificates</h3>
<div class="pull-right">
<span class="clickable filter" data-toggle="tooltip" title="Toggle table filter" data-container="body">
<i class="glyphicon glyphicon-filter"></i>
</span>
</div>
</div>
<div class="panel-body">
<input type="text" class="form-control" id="cacert-table-filter" data-action="filter" data-filters="#cacert-table" placeholder="Filter Columns" />
</div>
<table class="table table-hover" id="cacert-table">
<thead>
<tr>
<th>#</th>
<th>Name</th>
<th>Common Name</th>
<th>Signature Date</th>
<th>Expiration Date</th>
<th></th>
</tr>
</thead>
<tbody>
{% for cert in data_list -%}
<tr>
<td>{{ cert['index'] }}</td>
<td><a href="/crt/{{ cert['crt_id'] }}">{{ cert['crt_id'] }}</a></td>
<td>{{ cert['common_name'] }}</td>
<td>{{ cert['start_before'] }}</td>
<td>{{ cert['expire_after'] }}</td>
<td><a class="btn btn-default" href="/crt/{{ cert['crt_id'] }}" role="button" title="Download file"><i class="fa fa-download" aria-hidden="true"></i></a></td>
</tr>
{% endfor -%}
</tbody>
</table>
</div>
</div>
</div>
{% endblock %}
\ No newline at end of file
<!DOCTYPE html>
<html>
<head>
{% include "head.html" %}
</head>
<body>
{% block body %}
<div class="container-fluid">
<div class="row">
<div class="nav-side-menu">
<div class="brand">Certificate Authority</div>
<i class="fa fa-bars fa-2x toggle-btn" data-toggle="collapse" data-target="#menu-content"></i>
<div class="menu-list">
<ul id="menu-content" class="menu-content collapse out">
{% if not session.user_id %}
<li>
<a href="/">
<i class="fa fa-home" aria-hidden="true"></i> Public Home
</a>
</li>
<li>
<a href="/user/sign-in">
<i class="fa fa-cog" aria-hidden="true"></i> Manage Certificates
</a>
</li>
{% else -%}
<li>
<a href="/admin/">
<i class="fa fa-home" aria-hidden="true"></i> Signed Certificates
</a>
</li>
<li><a href="/admin/csr_requests"><i class="fa fa-tachometer" aria-hidden="true"></i> Manage CSR
<span style="font-weight: bold; margin-left: 5px; margin-right: 5px; color: #56d8ce;">[ {{ session.count_csr }} ] </span></a></li>
<!--<li><a href="/signed_certs"><i class="fa fa-check-square" aria-hidden="true"></i> Signed Certificates</a></li>
<li><a href="/revoked_certs"><i class="fa fa-minus-square" aria-hidden="true"></i> Revoked Certificates</a></li>-->
<li><a href="/admin/profile"><i class="fa fa-user" aria-hidden="true"></i> User Profile</a></li>
<!--<li><a href="/admin/logs"><i class="fa fa-book" aria-hidden="true"></i> Certificate Authority Logs</a></li>-->
<li><a href="/admin/logout"><i class="fa fa-sign-out" aria-hidden="true"></i> Logout</a></li>
{% endif -%}
</ul>
</div>
</div>
<div class="container" id="main">
<div class="flashes-messages">
{% with messages = get_flashed_messages(with_categories=true) %}
<!-- Categories: success (green), info (blue), warning (yellow), danger (red) -->
{% if messages %}
{% for category, message in messages %}
<div class="alert alert-{{ category }} alert-dismissible" role="alert">
<button type="button" class="close" data-dismiss="alert" aria-label="Close"><span aria-hidden="true">&times;</span></button>
{{ message|safe }}
</div>
{% endfor %}
{% endif %}
{% endwith %}
</div>
{% block pre_content %}{% endblock %}
{% block content %}{% endblock %}
{% block post_content %}{% endblock %}
</div>
</div>
</div>
{% endblock %}
{% include "footer.html" %}
</body>
</html>
\ No newline at end of file
{% macro render_field(field, label=None, label_visible=true, right_url=None, right_label=None, readonly=false) -%}
<div class="form-group {% if field.errors %}has-error{% endif %} {{ kwargs.pop('class_', '') }}">
{% if field.type != 'HiddenField' and label_visible %}
{% if not label %}{% set label=field.label.text %}{% endif %}
<label for="{{ field.id }}" class="control-label">{{ label|safe }}</label>
{% endif %}
{{ field(class_='form-control', readonly=readonly, **kwargs) }}
{% if field.errors %}
{% for e in field.errors %}
<p class="help-block">{{ e }}</p>
{% endfor %}
{% endif %}
</div>
{%- endmacro %}
{% macro render_checkbox_field(field, label=None) -%}
{% if not label %}{% set label=field.label.text %}{% endif %}
<div class="checkbox">
<label>
{{ field(type='checkbox', **kwargs) }} {{ label }}
</label>
</div>
{%- endmacro %}
{% macro render_radio_field(field) -%}
{% for value, label, checked in field.iter_choices() %}
<div class="radio">
<label>
<input type="radio" name="{{ field.id }}" id="{{ field.id }}" value="{{ value }}"{% if checked %} checked{% endif %}>
{{ label }}
</label>
</div>
{% endfor %}
{%- endmacro %}
{% macro render_submit_field(field, label=None, tabindex=None) -%}
{% if not label %}{% set label=field.label.text %}{% endif %}
{#<button type="submit" class="form-control btn btn-lg btn-primary btn-block">{{label}}</button>#}
<input type="submit" class="btn btn-lg btn-primary btn-block" value="{{label}}"
{% if tabindex %}tabindex="{{ tabindex }}"{% endif %}
>
{%- endmacro %}
\ No newline at end of file
{% extends "layout.html" %}
{% block content %}
<div class="page-header">
<h1>Administration <small>Certificate authority web</small></h1>
</div>
<div class="row">
<div class="col-md-12">
<div class="panel panel-primary margin-top-40 table">
<div class="panel-heading">
<h3 class="panel-title">Certificates Signature request list</h3>
<div class="pull-right">
<span class="clickable filter" data-toggle="tooltip" title="Toggle table filter" data-container="body">
<i class="glyphicon glyphicon-filter"></i>
</span>
</div>
</div>
<div class="panel-body">
<input type="text" class="form-control" id="cacert-table-filter" data-action="filter" data-filters="#cacert-table" placeholder="Filter Columns" />
</div>
<table class="table table-hover" id="cacert-table">
<thead>
<tr>
<th class="hidden-xs">#</th>
<th class="hidden-xs">CSR ID</th>
<th class="hidden-xs">CRT ID</th>
<th>Common Name</th>
<th class="hidden-xs">Request Date</th>
<th></th>
</tr>
</thead>
<tbody>
{% for csr in data_list -%}
<tr>
<td class="hidden-xs">{{ csr['index'] }}</td>
<td class="hidden-xs">{{ csr['csr_id'] }}</td>
<td class="hidden-xs">{{ csr['crt_id'] }}</td>
<td>{{ csr['common_name'] }}</td>
<td class="hidden-xs">{{ csr['creation_date'] }}</td>
<td>
<div class="btn-group">
<button type="button" class="btn btn-default dropdown-toggle" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
Action <span class="caret"></span>
</button>
<ul class="dropdown-menu dropdown-menu-right">
<li><a href="/admin/signcert?csr_id={{ csr['csr_id'] }}"><i class="fa fa-check-square" aria-hidden="true"></i> Sign</a></li>
<li><a href="/csr/{{ csr['csr_id'] }}"><i class="fa fa-eye" aria-hidden="true"></i> Download</a></li>
<li role="separator" class="divider"></li>
<li><a href="/admin/deletecsr?csr_id={{ csr['csr_id'] }}"><i class="fa fa-times" aria-hidden="true"></i> Delete</a></li>
</ul>
</div>
</td>
</tr>
{% endfor -%}
</tbody>
</table>
</div>
</div>
</div>
{% endblock %}
\ No newline at end of file
{% extends "layout.html" %}
{% block content %}
<div class="page-header">
<h1>User account information</h1>
</div>
<div style="padding: 15px">
<p>
<a class="btn btn-default" href="{{ url_for('user.change_password') }}" role="button" title="Download file">
<i class="fa fa-pencil-square-o" aria-hidden="true"></i> Change password</a>
</p>
{% from "macros.html" import render_field, render_submit_field %}
<form action="" method="POST" class="form" role="form">
<div class="row">
<div class="col-sm-6 col-md-5 col-lg-4">
{{ form.hidden_tag() }}
{{ render_field(form.username, tabindex=230, readonly=true) }}
{{ render_field(form.first_name, tabindex=240) }}
{{ render_field(form.last_name, tabindex=250) }}
{{ render_field(form.email, tabindex=260) }}
{{ render_submit_field(form.submit, tabindex=280) }}
</div>
</div>
</form>
</div>
{% endblock %}
\ No newline at end of file
{% extends "layout.html" %}
{% block content %}
<div class="page-header">
<h1>View {{ cert_type }} Details <small></small></h1>
</div>
<div class="row">
<div class="col-md-12">
<div class="panel panel-default">
<div class="panel-heading">
<h3 class="panel-title">{{ name |safe }}</h3>
</div>
<div class="panel-body">
<pre>{{ content }}</pre>
</div>
</div>
</div>
</div>
{% endblock %}
\ No newline at end of file
{% extends "layout.html" %}
{% block content %}
<div class="page-header">
<h1>Certificate Authority <small>view logs content</small></h1>
</div>
<div class="row">
<div class="col-md-12">
<div class="panel panel-default">
<div class="panel-heading">
<h3 class="panel-title">{{ filename }}</h3>
</div>
<div class="panel-body">
<p>
<a class="btn btn-default" href="/admin/view_logs?full=true" role="button" title="Download file">
<i class="fa fa-file-text" aria-hidden="true"></i> Full log</a>
<a class="btn btn-default" href="/admin/view_logs" role="button" title="Download file">
<i class="fa fa-file-text" aria-hidden="true"></i> Tail log</a>
</p>
<pre style="max-height: 600px;">{{ content }}</pre>
</div>
</div>
</div>
</div>
{% endblock %}
\ No newline at end of file
# This file is part of caucase
# Copyright (C) 2017 Nexedi
# Alain Takoudjou <alain.takoudjou@nexedi.com>
# Vincent Pelletier <vincent@nexedi.com>
#
# caucase is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# caucase is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
"""
Caucase - Certificate Authority for Users, Certificate Authority for SErvices
Test suite
"""
from __future__ import absolute_import
from cStringIO import StringIO
import datetime
import errno
import glob
import ipaddress
import os
import multiprocessing
import random
import shutil
import socket
import sqlite3
import sys
import tempfile
import time
import urlparse
import unittest
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from caucase import cli
from caucase.client import CaucaseError
from caucase import http
from caucase import utils
from caucase import exceptions
from caucase import wsgi
from caucase.storage import SQLite3Storage
_cryptography_backend = default_backend()
NOT_CAUCASE_OID = '2.25.285541874270823339875695650038637483518'
def canConnect(address):
"""
Returns True if a connection can be established to given address, False
otherwise.
"""
try:
socket.create_connection(address)
except socket.error, e:
if e.errno == errno.ECONNREFUSED:
return False
raise
return True
def retry(callback, try_count=10, try_delay=0.1):
"""
Poll <callback> every <try_delay> for <try_count> times or until it returns
a true value.
Always returns the value returned by latest callback invocation.
"""
for _ in xrange(try_count):
result = callback()
if result:
return result
time.sleep(try_delay)
class CaucaseTest(unittest.TestCase):
"""
Test a complete caucase setup: spawn a caucase-http server on CAUCASE_NETLOC
and use caucase-cli to access it.
"""
_server = None
def setUp(self):
"""
Prepare test data directory and file paths, and start caucased as most
tests will need to interact with it.
"""
self._data_dir = data_dir = tempfile.mkdtemp(prefix='caucase_test_')
self._client_dir = client_dir = os.path.join(data_dir, 'client')
os.mkdir(client_dir)
# pylint: disable=bad-whitespace
self._client_ca_crt = os.path.join(client_dir, 'cas.crt.pem')
self._client_user_ca_crt = os.path.join(client_dir, 'cau.crt.pem')
self._client_crl = os.path.join(client_dir, 'cas.crl.pem')
self._client_user_crl = os.path.join(client_dir, 'cau.crl.pem')
# pylint: enable=bad-whitespace
self._server_dir = server_dir = os.path.join(data_dir, 'server')
os.mkdir(server_dir)
# pylint: disable=bad-whitespace
self._server_db = os.path.join(server_dir, 'caucase.sqlite')
self._server_key = os.path.join(server_dir, 'server.key.pem')
self._server_backup_path = os.path.join(server_dir, 'backup')
# pylint: enable=bad-whitespace
os.mkdir(self._server_backup_path)
self._server_netloc = netloc = os.getenv('CAUCASE_NETLOC', 'localhost:8000')
self._caucase_url = 'http://' + netloc
parsed_url = urlparse.urlparse(self._caucase_url)
self.assertFalse(
canConnect((parsed_url.hostname, parsed_url.port)),
'Something else is already listening on %r, define CAUCASE_NETLOC '
'environment variable with a different ip/port' % (netloc, ),
)
self._startServer()
def tearDown(self):
"""
Stop any running caucased and delete all test data files.
"""
if self._server.is_alive():
self._stopServer()
else:
print 'Server exited with status: %s' % (self._server.exitcode, )
shutil.rmtree(self._data_dir)
def _restoreServer(
self,
backup_path,
key_path,
new_csr_path,
new_key_path,
try_count=10,
):
"""
Start caucased in its special --restore-backup mode. It will exit once
done.
Returns its exit status.
"""
server = multiprocessing.Process(
target=http.main,
kwargs={
'argv': (
'--db', self._server_db,
'--server-key', self._server_key,
'--netloc', self._server_netloc,
#'--threshold', '31',
#'--key-len', '2048',
'--backup-directory', self._server_backup_path,
'--restore-backup',
backup_path,
key_path,
new_csr_path,
new_key_path,
),
}
)
server.daemon = True
server.start()
# Must exit after a (short) while
if not retry(lambda: not server.is_alive(), try_count=try_count):
raise AssertionError('Backup restoration took more than %i second' % (
try_count / 10,
))
return server.exitcode
def _startServer(self, *argv):
"""
Start caucased server
"""
self._server = server = multiprocessing.Process(
target=http.main,
kwargs={
'argv': (
'--db', self._server_db,
'--server-key', self._server_key,
'--netloc', self._server_netloc,
#'--threshold', '31',
#'--key-len', '2048',
) + argv,
}
)
server.daemon = True
server.start()
parsed_url = urlparse.urlparse(self._caucase_url)
if not retry(
lambda: canConnect((parsed_url.hostname, parsed_url.port)),
):
self._stopServer()
raise AssertionError('Could not connect to %r after 1 second' % (
self._caucase_url,
))
def _stopServer(self):
"""
Stop a running caucased server
"""
server = self._server
server.terminate()
server.join(.1)
if server.is_alive():
# Sometimes, server survives to a SIGTERM. Maybe an effect of it being
# multi-threaded, or something in python which would catch SystemExit ?
# It does typically succeed on second try, so just do that.
server.terminate()
server.join(.1)
if server.is_alive():
raise ValueError('pid %i does not wish to die' % (server.pid, ))
def _runClient(self, *argv):
"""
Run client with given arguments.
Returns stdout.
"""
orig_stdout = sys.stdout
sys.stdout = stdout = StringIO()
try:
cli.main(
argv=(
'--ca-url', self._caucase_url,
'--ca-crt', self._client_ca_crt,
'--user-ca-crt', self._client_user_ca_crt,
'--crl', self._client_crl,
'--user-crl', self._client_user_crl,
) + argv,
)
except SystemExit:
pass
finally:
sys.stdout = orig_stdout
return stdout.getvalue()
@staticmethod
def _setCertificateRemainingLifeTime(key, crt, delta):
"""
Re-sign <crt> with <key>, shifting both its not_valid_before and
not_valid_after dates so that its remaining validity period
becomes <delta> and its validity span stays unchanged.
"""
new_not_valid_after_date = datetime.datetime.utcnow() + delta
return x509.CertificateBuilder(
subject_name=crt.subject,
issuer_name=crt.issuer,
not_valid_before=new_not_valid_after_date - (
crt.not_valid_after - crt.not_valid_before
),
not_valid_after=new_not_valid_after_date,
serial_number=crt.serial_number,
public_key=crt.public_key(),
extensions=crt.extensions,
).sign(
private_key=key,
algorithm=crt.signature_hash_algorithm,
backend=_cryptography_backend,
)
def _setCACertificateRemainingLifeTime(self, mode, serial, delta):
"""
Find the CA certificate with <serial> in caucase <mode> ("service"
or "user") and pass it to _setCertificateRemainingLifeTime with <delta>.
"""
int(serial) # Must already be an integer
prefix = {
'user': 'cau',
'service': 'cas',
}[mode]
db = sqlite3.connect(self._server_db)
db.row_factory = sqlite3.Row
with db:
c = db.cursor()
c.execute(
'SELECT rowid, key, crt FROM ' + prefix + 'ca',
)
while True:
row = c.fetchone()
if row is None:
raise Exception('CA with serial %r not found' % (serial, ))
crt = utils.load_ca_certificate(row['crt'].encode('ascii'))
if crt.serial_number == serial:
new_crt = self._setCertificateRemainingLifeTime(
key=utils.load_privatekey(row['key'].encode('ascii')),
crt=crt,
delta=delta,
)
new_crt_pem = utils.dump_certificate(new_crt)
c.execute(
'UPDATE ' + prefix + 'ca SET '
'expiration_date=?, crt=? '
'WHERE rowid=?',
(
utils.datetime2timestamp(new_crt.not_valid_after),
new_crt_pem,
row['rowid'],
),
)
return new_crt_pem
def _getBaseName(self):
"""
Returns a random file name, prefixed by data directory.
"""
return os.path.join(
self._data_dir,
str(random.getrandbits(32)),
)
@staticmethod
def _createPrivateKey(basename, key_len=2048):
"""
Create a private key and store it to file.
"""
name = basename + '.key.pem'
assert not os.path.exists(name)
with open(name, 'w') as key_file:
key_file.write(utils.dump_privatekey(
utils.generatePrivateKey(key_len=key_len),
))
return name
@staticmethod
def _getBasicCSRBuilder():
"""
Initiate a minimal CSR builder.
"""
return x509.CertificateSigningRequestBuilder(
subject_name=x509.Name([
x509.NameAttribute(
oid=x509.oid.NameOID.COMMON_NAME,
value=u'test',
),
]),
)
@staticmethod
def _finalizeCSR(basename, key_path, csr_builder):
"""
Sign, serialise and store given CSR Builder to file.
"""
name = basename + '.csr.pem'
assert not os.path.exists(name)
with open(name, 'w') as csr_file:
csr_file.write(
utils.dump_certificate_request(
csr_builder.sign(
private_key=utils.load_privatekey(utils.getKey(key_path)),
algorithm=utils.DEFAULT_DIGEST_CLASS(),
backend=_cryptography_backend,
),
),
)
return name
def _createBasicCSR(self, basename, key_path):
"""
Creates a basic CSR and returns its path.
"""
return self._finalizeCSR(
basename,
key_path,
self._getBasicCSRBuilder(),
)
def _createFirstUser(self, add_extensions=False):
"""
Create first user, whose CSR is automatically signed.
"""
basename = self._getBaseName()
user_key_path = self._createPrivateKey(basename)
csr_builder = self._getBasicCSRBuilder()
if add_extensions:
csr_builder = csr_builder.add_extension(
x509.CertificatePolicies([
x509.PolicyInformation(
x509.oid.ObjectIdentifier(NOT_CAUCASE_OID),
None,
)
]),
critical=False,
)
csr_path = self._finalizeCSR(
basename,
user_key_path,
csr_builder,
)
out, = self._runClient(
'--mode', 'user',
'--send-csr', csr_path,
).splitlines()
csr_id, csr_path_out = out.split()
# Sanity check output
self.assertEqual(csr_path, csr_path_out)
int(csr_id)
self.assertRaises(TypeError, utils.getCert, user_key_path)
self._runClient(
'--mode', 'user',
'--get-crt', csr_id, user_key_path,
)
# Does not raise anymore, we have a certificate
utils.getCert(user_key_path)
return user_key_path
def _createAndApproveCertificate(self, user_key_path, mode):
"""
Create a CSR, submit it, approve it and retrieve the certificate.
"""
basename = self._getBaseName()
key_path = self._createPrivateKey(basename)
csr_path = self._createBasicCSR(basename, key_path)
out, = self._runClient(
'--mode', mode,
'--send-csr', csr_path,
).splitlines()
csr_id, csr_path_out = out.split()
# Sanity check output
self.assertEqual(csr_path, csr_path_out)
int(csr_id)
self.assertRaises(TypeError, utils.getCert, key_path)
out = self._runClient(
'--mode', mode,
'--get-crt', csr_id, key_path,
).splitlines()
self.assertRaises(TypeError, utils.getCert, key_path)
self.assertEqual([csr_id + ' CSR still pending'], out)
csr2_path = csr_path + '.2'
self._runClient(
'--mode', mode,
'--get-csr', csr_id, csr2_path,
)
self.assertEqual(open(csr_path).read(), open(csr2_path).read())
# Sign using user cert
# Note: assuming user does not know the csr_id and keeps their own copy of
# issued certificates.
out = self._runClient(
'--mode', mode,
'--user-key', user_key_path,
'--list-csr',
).splitlines()
self.assertEqual([csr_id], [x.split(None, 1)[0] for x in out[2:-1]])
self.assertRaises(
CaucaseError,
self._runClient,
'--mode', mode,
'--user-key', user_key_path,
'--sign-csr', str(int(csr_id) + 1),
)
out = self._runClient(
'--mode', mode,
'--user-key', user_key_path,
'--sign-csr', csr_id,
)
self.assertRaises(
CaucaseError,
self._runClient,
'--mode', mode,
'--user-key', user_key_path,
'--sign-csr', csr_id,
)
# Now requester can get their certificate
out, = self._runClient(
'--mode', mode,
'--get-crt', csr_id, key_path,
).splitlines()
# Does not raise anymore, we have a certificate
utils.getCert(user_key_path)
return key_path
def testBasicUsage(self):
"""
Everybody plays by the rules (which includes trying to access when
revoked).
"""
self.assertFalse(os.path.exists(self._client_ca_crt))
self.assertFalse(os.path.exists(self._client_crl))
self.assertFalse(os.path.exists(self._client_user_ca_crt))
self.assertFalse(os.path.exists(self._client_user_crl))
# Running client creates CAS files (service CA & service CRL)
self._runClient()
self.assertTrue(os.path.exists(self._client_ca_crt))
self.assertTrue(os.path.exists(self._client_crl))
self.assertFalse(os.path.exists(self._client_user_ca_crt))
self.assertFalse(os.path.exists(self._client_user_crl))
# Running in "user" mode also created the CAU CA, but not the CAU CRL
self._runClient('--mode', 'user')
self.assertTrue(os.path.exists(self._client_ca_crt))
self.assertTrue(os.path.exists(self._client_crl))
self.assertTrue(os.path.exists(self._client_user_ca_crt))
self.assertFalse(os.path.exists(self._client_user_crl))
cas_crt_list = [
utils.load_ca_certificate(x)
for x in utils.getCertList(self._client_ca_crt)
]
cau_crt_list = [
utils.load_ca_certificate(x)
for x in utils.getCertList(self._client_user_ca_crt)
]
# No CA renewal happened yet
self.assertEqual(len(cas_crt_list), 1)
self.assertEqual(len(cau_crt_list), 1)
# Get a user key pair
user_key_path = self._createFirstUser()
# It must have been auto-signed
self.assertTrue(utils.isCertificateAutoSigned(utils.load_certificate(
# utils.getCert(user_key_path) does not raise anymore
utils.getCert(user_key_path),
cau_crt_list,
None,
)))
# Get a not-auto-approved service crt (the first auto-approved one was for
# the http server itself)
service_key = self._createAndApproveCertificate(
user_key_path,
'service',
)
self.assertFalse(utils.isCertificateAutoSigned(utils.load_certificate(
utils.getCert(service_key),
cas_crt_list,
None,
)))
# Get a not-auto-approved user crt
user2_key_path = self._createAndApproveCertificate(
user_key_path,
'user',
)
self.assertFalse(utils.isCertificateAutoSigned(utils.load_certificate(
utils.getCert(user2_key_path),
cau_crt_list,
None,
)))
# It can itself sign certificates...
service2_key_path = self._createAndApproveCertificate(
user2_key_path,
'service',
)
user3_key_path = self._createAndApproveCertificate(
user2_key_path,
'user',
)
self._runClient(
'--user-key', user2_key_path,
'--list-csr',
)
self._runClient(
'--mode', 'user',
'--user-key', user2_key_path,
'--list-csr',
)
# ...until it gets revoked
self._runClient(
'--user-key', user_key_path,
'--mode', 'user',
'--revoke-other-crt', user2_key_path,
'--update-user',
)
self.assertRaises(
CaucaseError,
self._createAndApproveCertificate,
user2_key_path,
'service',
)
self.assertRaises(
CaucaseError,
self._createAndApproveCertificate,
user2_key_path,
'user',
)
self.assertRaises(
CaucaseError,
self._runClient,
'--user-key', user2_key_path,
'--list-csr',
)
self.assertRaises(
CaucaseError,
self._runClient,
'--mode', 'user',
'--user-key', user2_key_path,
'--list-csr',
)
# But the user it approved still works...
self._runClient(
'--user-key', user3_key_path,
'--list-csr',
)
# ...until it revokes itself
self._runClient(
'--mode', 'user',
'--user-key', user3_key_path,
'--revoke-serial', str(
utils.load_certificate(
utils.getCert(user3_key_path),
cau_crt_list,
None,
).serial_number,
)
)
self.assertRaises(
CaucaseError,
self._runClient,
'--user-key', user3_key_path,
'--list-csr',
)
# And the service it approved works too
service2_crt_before, service2_key_before, _ = utils.getKeyPair(
service2_key_path,
)
self._runClient(
# 100 days is longer than certificate life, so it will be immediately
# renewed.
'--threshold', '100',
'--renew-crt', service2_key_path, '',
)
service2_crt_after, service2_key_after, _ = utils.getKeyPair(
service2_key_path,
)
# Certificate and key were renewed...
self.assertNotEqual(service2_crt_before, service2_crt_after)
self.assertNotEqual(service2_key_before, service2_key_after)
# ...and not just swapped
self.assertNotEqual(service2_crt_before, service2_key_after)
self.assertNotEqual(service2_key_before, service2_crt_after)
# It can revoke itself...
self._runClient(
'--revoke-crt', service2_key_path, '',
)
# ...and then it cannot renew itself any more...
self.assertRaises(
CaucaseError,
self._runClient,
'--threshold', '100',
'--renew-crt', service2_key_path, '',
)
service2_crt_after2, service2_key_after2, _ = utils.getKeyPair(
service2_key_path,
)
# and crt & key did not change
self.assertEqual(service2_crt_after, service2_crt_after2)
self.assertEqual(service2_key_after, service2_key_after2)
# revoking again one's own certificate fails
self.assertRaises(
CaucaseError,
self._runClient,
'--revoke-crt', service2_key_path, '',
)
# as does revoking with an authenticated user
self.assertRaises(
CaucaseError,
self._runClient,
'--user-key', user_key_path,
'--revoke-other-crt', service2_key_path,
)
# and revoking by serial
self.assertRaises(
CaucaseError,
self._runClient,
'--user-key', user_key_path,
'--revoke-serial', str(
utils.load_certificate(
utils.getCert(service2_key_path),
cas_crt_list,
None,
).serial_number,
),
)
# Rejecting a CSR
basename = self._getBaseName()
key_path = self._createPrivateKey(basename)
csr_path = self._createBasicCSR(basename, key_path)
out, = self._runClient(
'--send-csr', csr_path,
).splitlines()
csr_id, csr_path_out = out.split()
# Sanity check output
self.assertEqual(csr_path, csr_path_out)
int(csr_id)
self.assertRaises(TypeError, utils.getCert, key_path)
out = self._runClient(
'--get-crt', csr_id, key_path,
).splitlines()
self.assertRaises(TypeError, utils.getCert, key_path)
self.assertEqual([csr_id + ' CSR still pending'], out)
out = self._runClient(
'--user-key', user_key_path,
'--reject-csr', csr_id,
).splitlines()
# Re-rejecting fails
self.assertRaises(
CaucaseError,
self._runClient,
'--user-key', user_key_path,
'--reject-csr', csr_id,
)
# like rejecting a non-existing crt
self.assertRaises(
CaucaseError,
self._runClient,
'--user-key', user_key_path,
'--reject-csr', str(int(csr_id) + 1),
)
out = self._runClient(
'--get-crt', csr_id, key_path,
).splitlines()
self.assertRaises(TypeError, utils.getCert, key_path)
self.assertEqual([
csr_id + ' not found - either csr id has a typo or CSR was rejected'
], out)
def testUpdateUser(self):
"""
Verify that CAU certificate and revocation list are created when the
(rarely needed) --update-user option is given.
"""
self.assertFalse(os.path.exists(self._client_ca_crt))
self.assertFalse(os.path.exists(self._client_crl))
self.assertFalse(os.path.exists(self._client_user_ca_crt))
self.assertFalse(os.path.exists(self._client_user_crl))
self._runClient('--update-user')
self.assertTrue(os.path.exists(self._client_ca_crt))
self.assertTrue(os.path.exists(self._client_crl))
self.assertTrue(os.path.exists(self._client_user_ca_crt))
self.assertTrue(os.path.exists(self._client_user_crl))
def testMaxCSR(self):
"""
Verify that the number of pending CSR is properly constrained.
"""
csr_list = []
def assertCanSend(count):
"""
Check that caucased accepts <count> CSR, and rejects the next one.
Appends the data of created CSRs (csr_id and csr_path) to csr_list.
"""
for _ in xrange(count):
basename = self._getBaseName()
csr_path = self._createBasicCSR(
basename,
self._createPrivateKey(basename),
)
out, = self._runClient('--send-csr', csr_path).splitlines()
csr_id, _ = out.split()
csr_list.append((csr_id, csr_path))
basename = self._getBaseName()
bad_csr_path = self._createBasicCSR(
basename,
self._createPrivateKey(basename),
)
self.assertRaises(
CaucaseError,
self._runClient,
'--send-csr',
bad_csr_path,
)
user_key_path = self._createFirstUser()
self._stopServer()
self._startServer(
'--service-max-csr', '5',
)
assertCanSend(5)
# But resubmitting one of the accepted ones is still fine
_, csr_path = csr_list[0]
self._runClient('--send-csr', csr_path)
# Accepted certificates do not count towards the total, even if not
# retrieved by owner
csr_id, csr_path = csr_list.pop()
self._runClient(
'--user-key', user_key_path,
'--sign-csr', csr_id,
)
assertCanSend(1)
# Rejected certificates do not count towards the total.
csr_id, _ = csr_list.pop()
self._runClient(
'--user-key', user_key_path,
'--reject-csr', csr_id,
)
assertCanSend(1)
def testLockAutoSignAmount(self):
"""
Verify that auto-approve limit freezing works.
"""
self._stopServer()
self._startServer(
'--user-auto-approve-count', '2',
'--lock-auto-approve-count',
)
self._stopServer()
self._startServer(
'--user-auto-approve-count', '3',
)
self._createFirstUser()
self._createFirstUser()
self.assertRaises(TypeError, self._createFirstUser)
self._stopServer()
self._startServer(
'--user-auto-approve-count', '3',
'--lock-auto-approve-count',
)
self.assertRaises(TypeError, self._createFirstUser)
def testCSRFiltering(self):
"""
Verify that requester cannot get any extension or extension value they
ask for. Caucase has to protect itself to be trustworthy, but also to let
some liberty to requester.
"""
def checkCRT(key_path):
"""
Verify key_path to contain exactly one certificate, itself containing
all expected extensions.
"""
crt = utils.load_certificate(
utils.getCert(key_path),
cas_crt_list,
None,
)
# CA-only extension, must not be present in certificate
self.assertRaises(
x509.ExtensionNotFound,
crt.extensions.get_extension_for_class,
x509.NameConstraints,
)
for expected_value in [
expected_key_usage,
expected_extended_usage,
expected_alt_name,
expected_policies,
expected_basic_constraints,
]:
extension = crt.extensions.get_extension_for_class(
expected_value.__class__,
)
self.assertEqual(
extension.value,
expected_value,
)
self.assertTrue(extension.critical)
requested_key_usage = x509.KeyUsage(
# pylint: disable=bad-whitespace
digital_signature =True,
content_commitment=True,
key_encipherment =True,
data_encipherment =True,
key_agreement =True,
key_cert_sign =True,
crl_sign =True,
encipher_only =True,
decipher_only =False,
# pylint: enable=bad-whitespace
)
expected_key_usage = x509.KeyUsage(
# pylint: disable=bad-whitespace
digital_signature =True,
content_commitment=True,
key_encipherment =True,
data_encipherment =True,
key_agreement =True,
key_cert_sign =False,
crl_sign =False,
encipher_only =True,
decipher_only =False,
# pylint: enable=bad-whitespace
)
requested_extended_usage = x509.ExtendedKeyUsage([
x509.oid.ExtendedKeyUsageOID.OCSP_SIGNING,
x509.oid.ExtendedKeyUsageOID.CLIENT_AUTH,
])
expected_extended_usage = x509.ExtendedKeyUsage([
x509.oid.ExtendedKeyUsageOID.CLIENT_AUTH,
])
requested_alt_name = expected_alt_name = x509.SubjectAlternativeName([
x509.RFC822Name('nobody@example.com'),
x509.DNSName('example.com'),
x509.UniformResourceIdentifier('https://example.com/a/b/c'),
x509.IPAddress(ipaddress.IPv4Address(u'127.0.0.1')),
x509.IPAddress(ipaddress.IPv6Address(u'::1')),
x509.IPAddress(ipaddress.IPv4Network(u'127.0.0.0/8')),
x509.IPAddress(ipaddress.IPv6Network(u'::/64')),
])
requested_policies = x509.CertificatePolicies([
x509.PolicyInformation(
x509.oid.ObjectIdentifier(utils.CAUCASE_OID_RESERVED),
None,
),
x509.PolicyInformation(
x509.oid.ObjectIdentifier(NOT_CAUCASE_OID),
None,
),
])
expected_policies = x509.CertificatePolicies([
x509.PolicyInformation(
x509.oid.ObjectIdentifier(NOT_CAUCASE_OID),
None,
),
])
requested_basic_constraints = x509.BasicConstraints(
ca=True,
path_length=42,
)
expected_basic_constraints = x509.BasicConstraints(
ca=False,
path_length=None,
)
# Check stored CSR filtering
user_key_path = self._createFirstUser(add_extensions=True)
basename = self._getBaseName()
key_path = self._createPrivateKey(basename)
requested_csr_path = self._finalizeCSR(
basename,
key_path,
self._getBasicCSRBuilder(
).add_extension(requested_key_usage, critical=True,
).add_extension(requested_extended_usage, critical=True,
).add_extension(requested_alt_name, critical=True,
).add_extension(requested_policies, critical=True,
).add_extension(requested_basic_constraints, critical=True,
).add_extension(
x509.NameConstraints([x509.DNSName('com')], None),
critical=True,
),
)
out, = self._runClient(
'--send-csr', requested_csr_path,
).splitlines()
csr_id, _ = out.split()
int(csr_id)
self._runClient(
'--user-key', user_key_path,
'--sign-csr', csr_id,
)
self._runClient(
'--get-crt', csr_id, key_path,
)
cas_crt_list = [
utils.load_ca_certificate(x)
for x in utils.getCertList(self._client_ca_crt)
]
cau_crt_list = [
utils.load_ca_certificate(x)
for x in utils.getCertList(self._client_user_ca_crt)
]
checkCRT(key_path)
# Check renewed CRT filtering does not alter clean signed certificate
# content (especially, caucase auto-signed flag must not appear).
before_key = open(key_path).read()
self._runClient(
'--threshold', '100',
'--renew-crt', key_path, '',
)
after_key = open(key_path).read()
assert before_key != after_key
checkCRT(key_path)
# Check content of auto-issued user certificate
user_crt = utils.load_certificate(
utils.getCert(user_key_path),
cau_crt_list,
None,
)
user_certificate_policies = user_crt.extensions.get_extension_for_class(
x509.CertificatePolicies,
)
self.assertEqual(
user_certificate_policies.value,
x509.CertificatePolicies([
x509.PolicyInformation(
x509.oid.ObjectIdentifier(NOT_CAUCASE_OID),
None,
),
utils.CAUCASE_POLICY_INFORMATION_AUTO_SIGNED,
]),
)
self.assertFalse(user_certificate_policies.critical)
# Check template CSR: must be taken into account, but it also gets
# filtered.
basename2 = self._getBaseName()
key_path2 = self._createPrivateKey(basename2)
out, = self._runClient(
'--send-csr', self._finalizeCSR(
basename2,
key_path2,
self._getBasicCSRBuilder(),
),
).splitlines()
csr_id, _ = out.split()
int(csr_id)
self._runClient(
'--user-key', user_key_path,
'--sign-csr-with', csr_id, requested_csr_path,
)
self._runClient(
'--get-crt', csr_id, key_path2,
)
checkCRT(key_path2)
def testCACertRenewal(self):
"""
Exercise CA certificate rollout procedure.
"""
user_key_path = self._createFirstUser()
cau_crt, = [
utils.load_ca_certificate(x)
for x in utils.getCertList(self._client_user_ca_crt)
]
self._stopServer()
# CA expires in 100 days: longer than one certificate life,
# but shorter than two. A new CA must be generated and distributed,
# but not used for new signatures yet.
new_cau_crt_pem = self._setCACertificateRemainingLifeTime(
'user',
cau_crt.serial_number,
datetime.timedelta(100, 0),
)
# As we will use this crt as trust anchor, we must make the client believe
# it knew it all along.
with open(self._client_user_ca_crt, 'w') as client_user_ca_crt_file:
client_user_ca_crt_file.write(new_cau_crt_pem)
self._startServer()
new_user_key = self._createAndApproveCertificate(
user_key_path,
'user',
)
# Must not raise: we are signed with the "old" ca.
utils.load_certificate(
utils.getCert(new_user_key),
[cau_crt],
None,
)
# We must now know the new CA
cau_crt_list = [
utils.load_ca_certificate(x)
for x in utils.getCertList(self._client_user_ca_crt)
]
new_cau_crt, = [
x for x in cau_crt_list
if x.serial_number != cau_crt.serial_number
]
self._stopServer()
# New CA now exists for 100 days: longer than one certificate life.
# It may (must) be used for new signatures.
self._setCACertificateRemainingLifeTime(
'user',
new_cau_crt.serial_number,
new_cau_crt.not_valid_after - new_cau_crt.not_valid_before -
datetime.timedelta(100, 0),
)
self._startServer()
self._runClient(
'--mode', 'user',
# 100 days is longer than certificate life, so it will be immediately
# renewed.
'--threshold', '100',
'--renew-crt', new_user_key, '',
)
self.assertRaises(
exceptions.CertificateVerificationError,
utils.load_certificate,
utils.getCert(new_user_key),
[cau_crt],
None,
)
utils.load_certificate(
utils.getCert(new_user_key),
cau_crt_list,
None,
)
def testCaucasedCertRenewal(self):
"""
Exercise caucased internal certificate renewal procedure.
"""
user_key_path = self._createFirstUser()
self._stopServer()
# If server certificate is deleted, it gets re-created, even it CAS
# reached its certificate auto-approval limit.
os.unlink(self._server_key)
self._startServer()
if not retry(lambda: os.path.exists(self._server_key)):
raise AssertionError('%r was not recreated within 1 second' % (
self._server_key,
))
# But user still trusts the server
self._runClient(
'--mode', 'user',
# 100 days is longer than certificate life, so it will be immediately
# renewed.
'--threshold', '100',
'--renew-crt', user_key_path, '',
)
# Server certificate will expire in 20 days, the key must be renewed
# (but we have to peek at CAS private key, cover your eyes)
(cas_key, ), = sqlite3.connect(
self._server_db,
).cursor().execute(
'SELECT key FROM casca',
).fetchall()
self._stopServer()
crt_pem, key_pem, _ = reference_key_pair_result = utils.getKeyPair(
self._server_key,
)
with open(self._server_key, 'w') as server_key_file:
server_key_file.write(key_pem)
server_key_file.write(utils.dump_certificate(
self._setCertificateRemainingLifeTime(
key=utils.load_privatekey(cas_key.encode('ascii')),
crt=utils.load_certificate(
crt_pem,
[
utils.load_ca_certificate(x)
for x in utils.getCertList(self._client_ca_crt)
],
None,
),
delta=datetime.timedelta(20, 0)
)
))
self._startServer()
if not retry(
lambda: utils.getKeyPair(self._server_key) != reference_key_pair_result,
):
raise AssertionError('Server did not renew its key pair within 1 second')
# But user still trusts the server
self._runClient(
'--mode', 'user',
# 100 days is longer than certificate life, so it will be immediately
# renewed.
'--threshold', '100',
'--renew-crt', user_key_path, '',
)
def testWSGI(self):
"""
Test wsgi class reaction to malformed requests.
For tests which are not accessible through the client module (as it tries
to only produce valid requests).
"""
self._runClient('--mode', 'user', '--update-user')
cau_list = [
utils.load_ca_certificate(x)
for x in utils.getCertList(self._client_user_ca_crt)
]
cau_crl = open(self._client_user_crl).read()
class DummyCAU(object):
"""
Mock CAU.
"""
def getCACertificateList(self):
"""
Return cau ca list.
"""
return cau_list
def getCertificateRevocationList(self):
"""
Return cau crl.
"""
return cau_crl
@staticmethod
def appendCertificateSigningRequest(_):
"""
Raise to exercise the "unexpected exception" code path in WSGI.
"""
raise ValueError('Some generic exception')
application = wsgi.Application(DummyCAU(), None)
def request(environ):
"""
Non-standard shorthand for invoking the WSGI application.
"""
start_response_list = []
body = list(application(
environ,
lambda status, header_list: start_response_list.append(
(status, header_list),
),
))
# pylint: disable=unbalanced-tuple-unpacking
(status, header_list), = start_response_list
# pylint: enable=unbalanced-tuple-unpacking
status, reason = status.split(' ', 1)
return int(status), reason, header_list, ''.join(body)
UNAUTHORISED_STATUS = 404
self.assertEqual(request({
'PATH_INFO': '/',
})[0], 404)
self.assertEqual(request({
'PATH_INFO': '/foo/bar',
})[0], 404)
self.assertEqual(request({
'PATH_INFO': '/cau',
})[0], 404)
self.assertEqual(request({
'PATH_INFO': '/cau/__init__',
})[0], 404)
self.assertEqual(request({
'PATH_INFO': '/cau/does_not_exist',
})[0], 404)
self.assertEqual(request({
'PATH_INFO': '/cau/crl/123',
'REQUEST_METHOD': 'GET',
})[0], 404)
self.assertEqual(request({
'PATH_INFO': '/cau/crl',
'REQUEST_METHOD': 'PUT',
})[0], 405)
self.assertEqual(request({
'PATH_INFO': '/cau/csr/123/456',
'REQUEST_METHOD': 'GET',
})[0], 404)
self.assertEqual(request({
'PATH_INFO': '/cau/csr/123',
'REQUEST_METHOD': 'POST',
})[0], 405)
self.assertEqual(request({
'PATH_INFO': '/cau/csr/a',
'REQUEST_METHOD': 'GET',
})[0], 400)
self.assertEqual(request({
'PATH_INFO': '/cau/csr',
'REQUEST_METHOD': 'GET',
})[0], UNAUTHORISED_STATUS)
self.assertEqual(request({
'PATH_INFO': '/cau/csr/123',
'REQUEST_METHOD': 'PUT',
})[0], 404)
self.assertEqual(request({
'PATH_INFO': '/cau/csr',
'REQUEST_METHOD': 'PUT',
'wsgi.input': StringIO(),
})[0], 500)
self.assertEqual(request({
'PATH_INFO': '/cau/csr',
'REQUEST_METHOD': 'DELETE',
})[0], 404)
self.assertEqual(request({
'PATH_INFO': '/cau/csr/123/456',
'REQUEST_METHOD': 'DELETE',
})[0], 404)
self.assertEqual(request({
'PATH_INFO': '/cau/csr/123',
'REQUEST_METHOD': 'DELETE',
})[0], UNAUTHORISED_STATUS)
self.assertEqual(request({
'PATH_INFO': '/cau/crt',
'REQUEST_METHOD': 'GET',
})[0], 404)
self.assertEqual(request({
'PATH_INFO': '/cau/crt/123/456',
'REQUEST_METHOD': 'GET',
})[0], 404)
self.assertEqual(request({
'PATH_INFO': '/cau/crt/a',
'REQUEST_METHOD': 'GET',
})[0], 400)
self.assertEqual(request({
'PATH_INFO': '/cau/crt/renew',
'REQUEST_METHOD': 'PUT',
'CONTENT_TYPE': 'text/plain',
})[0], 400)
self.assertEqual(request({
'PATH_INFO': '/cau/crt/renew',
'REQUEST_METHOD': 'PUT',
'CONTENT_TYPE': 'application/json',
'CONTENT_LENGTH': 'a',
})[0], 400)
self.assertEqual(request({
'PATH_INFO': '/cau/crt/renew',
'REQUEST_METHOD': 'PUT',
'CONTENT_TYPE': 'application/json',
'CONTENT_LENGTH': str(10 * 1024 * 1024 + 1),
})[0], 413)
self.assertEqual(request({
'PATH_INFO': '/cau/crt/renew',
'REQUEST_METHOD': 'PUT',
'CONTENT_TYPE': 'application/json',
'wsgi.input': StringIO('{'),
})[0], 400)
self.assertEqual(request({
'PATH_INFO': '/cau/crt/revoke',
'REQUEST_METHOD': 'PUT',
'CONTENT_TYPE': 'application/json',
'wsgi.input': StringIO('{"digest": null}'),
})[0], UNAUTHORISED_STATUS)
self.assertEqual(request({
'PATH_INFO': '/cau/crt/a',
'REQUEST_METHOD': 'PUT',
'CONTENT_TYPE': 'text/plain',
'wsgi.input': StringIO(''),
})[0], 400)
self.assertEqual(request({
'PATH_INFO': '/cau/crt/123',
'REQUEST_METHOD': 'PUT',
'CONTENT_TYPE': 'text/plain',
'wsgi.input': StringIO(''),
})[0], UNAUTHORISED_STATUS)
self.assertEqual(request({
'PATH_INFO': '/cau/crt/123',
'REQUEST_METHOD': 'PUT',
'CONTENT_TYPE': 'text/plain',
'wsgi.input': StringIO('foo'),
})[0], 400)
self.assertEqual(request({
'PATH_INFO': '/cau/crt/123',
'REQUEST_METHOD': 'POST',
})[0], 405)
def testProbe(self):
"""
Exercise caucase-probe command.
"""
cli.probe([self._caucase_url])
def testBackup(self):
"""
Exercise backup generation and restoration.
"""
backup_glob = os.path.join(self._server_backup_path, '*.sql.caucased')
user_key_path = self._createFirstUser()
user2_key_path = self._createAndApproveCertificate(
user_key_path,
'user',
)
# user2 sacrifice their private key, and prepare its replacement
basename = self._getBaseName()
user2_new_key_path = self._createPrivateKey(basename)
user2_new_csr_path = self._createBasicCSR(basename, user2_new_key_path)
# Restart caucased to not have to wait for next backup deadline
self._stopServer()
# Note: backup could have triggered between first and second user's key
# creation. We need it to be signed by both keys, so delete any backup file
# which would exist at this point.
for backup_path in glob.glob(backup_glob):
os.unlink(backup_path)
before_backup = list(SQLite3Storage(
self._server_db,
table_prefix='cau',
).dumpIterator())
self._startServer('--backup-directory', self._server_backup_path)
backup_path_list = retry(lambda: glob.glob(backup_glob))
if not backup_path_list:
raise AssertionError('Backup file not created after 1 second')
backup_path, = backup_path_list
self._stopServer()
# Server must refuse to restore if the database still exists
self.assertNotEqual(
self._restoreServer(
backup_path,
user2_key_path,
user2_new_csr_path,
user2_new_key_path,
),
0,
)
os.unlink(self._server_db)
os.unlink(self._server_key)
# XXX: just for the coverage... Should check output
cli.key_id([
'--private-key', user_key_path, user2_key_path,
'--backup', backup_path,
])
self.assertEqual(
self._restoreServer(
backup_path,
user2_key_path,
user2_new_csr_path,
user2_new_key_path,
),
0,
)
after_restore = list(SQLite3Storage(
self._server_db,
table_prefix='cau',
).dumpIterator())
CRL_INSERT = 'INSERT INTO "caucrl" '
CRT_INSERT = 'INSERT INTO "caucrt" '
REV_INSERT = 'INSERT INTO "caurevoked" '
def filterBackup(backup, received_csr, expect_rev):
"""
Remove all lines which are know to differ between original batabase and
post-restoration database, so the rest (which must be the majority of the
database) can be tested to be equal.
"""
rev_found = not expect_rev
new_backup = []
crt_list = []
for row in backup:
if (
row == received_csr
) or row.startswith(CRL_INSERT):
continue
if row.startswith(CRT_INSERT):
crt_list.append(row)
continue
if row.startswith(REV_INSERT):
if rev_found:
raise AssertionError('Unexpected revocation found')
continue
new_backup.append(row)
return new_backup, crt_list
before_backup, before_crt_list = filterBackup(
before_backup,
'INSERT INTO "caucounter" VALUES(\'received_csr\',2);\x00',
False,
)
after_restore, after_crt_list = filterBackup(
after_restore,
'INSERT INTO "caucounter" VALUES(\'received_csr\',3);\x00',
True,
)
self.assertEqual(
len(set(after_crt_list).difference(before_crt_list)),
1,
)
self.assertEqual(
len(set(before_crt_list).difference(after_crt_list)),
0,
)
self.assertItemsEqual(before_backup, after_restore)
self._startServer('--backup-directory', self._server_backup_path)
# user2 got a new certificate matching their new key
utils.getKeyPair(user2_new_key_path)
# And user 1 must still work without key change
self._runClient(
'--user-key', user_key_path,
'--list-csr',
)
# Another backup can happen after restoration
self._stopServer()
for backup_path in glob.glob(backup_glob):
os.unlink(backup_path)
self._startServer('--backup-directory', self._server_backup_path)
backup_path_list = retry(lambda: glob.glob(backup_glob))
if not backup_path_list:
raise AssertionError('Backup file not created after 1 second')
backup_path, = glob.glob(backup_glob)
cli.key_id([
'--backup', backup_path,
])
# Now, push a lot of data to exercise chunked checksum in backup &
# restoration code
self._stopServer()
for backup_path in glob.glob(backup_glob):
os.unlink(backup_path)
db = sqlite3.connect(self._server_db)
db.row_factory = sqlite3.Row
with db:
c = db.cursor()
c.execute('CREATE TABLE bloat (bloat TEXT)')
bloat_query = 'INSERT INTO bloat VALUES (?)'
bloat_value = ('bloat' * 10240, )
for _ in xrange(1024):
c.execute(bloat_query, bloat_value)
db.close()
del db
self._startServer('--backup-directory', self._server_backup_path)
backup_path_list = retry(lambda: glob.glob(backup_glob), try_count=20)
if not backup_path_list:
raise AssertionError('Backup file not created after 2 second')
backup_path, = glob.glob(backup_glob)
cli.key_id([
'--backup', backup_path,
])
self._stopServer()
os.unlink(self._server_db)
os.unlink(self._server_key)
backup_path, = backup_path_list
# user2 sacrifice their private key, and prepare its replacement
basename = self._getBaseName()
user2_newnew_key_path = self._createPrivateKey(basename)
user2_newnew_csr_path = self._createBasicCSR(
basename,
user2_newnew_key_path,
)
user2_new_bare_key_path = user2_new_key_path + '.bare_key'
with open(user2_new_bare_key_path, 'w') as bare_key_file:
bare_key_file.write(utils.getKeyPair(user2_new_key_path)[1])
self.assertEqual(
self._restoreServer(
backup_path,
user2_new_bare_key_path,
user2_newnew_csr_path,
user2_newnew_key_path,
try_count=50,
),
0,
)
# This file is part of caucase
# Copyright (C) 2017 Nexedi
# Alain Takoudjou <alain.takoudjou@nexedi.com>
# Vincent Pelletier <vincent@nexedi.com>
#
# caucase is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# caucase is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
# See http://peak.telecommunity.com/DevCenter/setuptools#namespace-packages
try:
__import__('pkg_resources').declare_namespace(__name__)
except ImportError:
from pkgutil import extend_path
__path__ = extend_path(__path__, __name__)
# This file is part of caucase
# Copyright (C) 2017 Nexedi
# Alain Takoudjou <alain.takoudjou@nexedi.com>
# Vincent Pelletier <vincent@nexedi.com>
#
# caucase is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# caucase is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
import os, time
import shutil
import tempfile
import unittest
import json
from datetime import datetime
from caucase import app, db
from OpenSSL import crypto, SSL
from caucase.exceptions import (NoStorage, NotFound, Found, BadSignature,
BadCertificateSigningRequest,
BadCertificate,
CertificateVerificationError,
ExpiredCertificate)
from caucase.ca import CertificateAuthority, DEFAULT_DIGEST_LIST, MIN_CA_RENEW_PERIOD
from caucase import utils
class CertificateAuthorityTest(unittest.TestCase):
def setUp(self):
self.ca_dir = tempfile.mkdtemp()
self.db_file = os.path.join(self.ca_dir, 'ca.db')
self.max_request_amount = 3
self.default_digest = "sha256"
self.crt_keep_time = 0
app.config.update(
DEBUG=True,
CSRF_ENABLED=True,
SECRET_KEY = 'This is an UNSECURE Secret. Please CHANGE THIS for production environments.',
TESTING=True,
SQLALCHEMY_DATABASE_URI='sqlite:///%s' % self.db_file
)
from caucase.storage import Storage
self._storage = Storage(db)
def make_ca(self, crt_life_time, auto_sign_csr=False):
return CertificateAuthority(
storage=self._storage,
ca_life_period=4,
ca_renew_period=2,
crt_life_time=crt_life_time,
crl_renew_period=0.1,
crl_base_url='http://crl.url.com',
ca_subject='/C=XX/ST=State/L=City/OU=OUnit/O=Company/CN=CAAuth/emailAddress=xx@example.com',
max_csr_amount=self.max_request_amount,
crt_keep_time=self.crt_keep_time,
auto_sign_csr=auto_sign_csr
)
def generateCSR(self, cn="toto.example.com", email="toto@example.com"):
key = crypto.PKey()
key.generate_key(crypto.TYPE_RSA, 2048)
req = crypto.X509Req()
subject = req.get_subject()
subject.CN = cn
subject.C = "CC"
subject.ST = "ST"
subject.L = "LOU"
subject.O = "OOU"
subject.OU = "OU"
subject.emailAddress = email
req.set_pubkey(key)
utils.X509Extension().setDefaultCsrExtensions(req)
req.sign(key, self.default_digest)
return (req, key)
def csr_tostring(self, csr):
return crypto.dump_certificate_request(crypto.FILETYPE_PEM, csr)
def get_fake_cert_key(self):
cert_string = """-----BEGIN CERTIFICATE-----
MIID6DCCAtCgAwIBAwIBBDANBgkqhkiG9w0BAQsFADCBljEiMCAGA1UEAwwZVGhl
IENlcnRpZmljYXRlIEF1dGhvcml0eTELMAkGA1UEBhMCWFgxDjAMBgNVBAgMBVN0
YXRlMREwDwYDVQQKDAhDb21wYWdueTENMAsGA1UECwwEVW5pdDENMAsGA1UEBwwE
Q2l0eTEiMCAGCSqGSIb3DQEJARYTY2EuYXV0aEBleGFtcGxlLmNvbTAeFw0xNzA0
MTYyMTQyNDVaFw0xODA0MTYyMTQyNDVaMBsxGTAXBgNVBAMMEGRhbmRAZXhhbXBs
ZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDrJNil62fkNm1j
UgEZ33hg5qYiLeNOEUgKaINCqhfQDuH7tTho+nRNxY2FSpv7ooyMckLYojNm+XEl
lUREE8hgIBiBWgiXazvoaxKFW2BIm7kpfxSC0t4pxwjehftm0Ny/nvms6SiE0ruL
3u+oUI9VVvgofra7mvhX3OZuZNb2QADaPnmyfB8VYGfzYAl0QgyFkrWzPflb/UXD
LdIP/niTpUHMgDTChQ+jf3tHm0pbsRZTxXISJY2+O5qpEgumW+Qcw5sKpjdfMYvH
hoM0IzMofBSfmQCZOjJRcisVLTASj5qN5+GFJi6Pz7oih203Ur8elq+iA0hRisA7
g37LNGXTAgMBAAGjgbowgbcwCQYDVR0TBAIwADAsBglghkgBhvhCAQ0EHxYdT3Bl
blNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFPOBwIfuP8mulzmk
MgC1VGLCkwEDMB8GA1UdIwQYMBaAFGXLZo/7QINvcowfmpUEllOAJ6I5MDwGA1Ud
HwQ1MDMwMaAvoC2GK2h0dHBzOi8vWzIwMDE6NjdjOjEyNTQ6ZTpjNDo6Yzc0OF06
ODAwOS9jcmwwDQYJKoZIhvcNAQELBQADggEBAKarSr7WKXznFjbLfbedrci9mtwo
TYVpOUt/nt6lCiJ2wTGQea/e4KQ3WRwlUUHCX/K+G4QEV8OeDIA4uXnx24fclj35
hCYQCaJfIM96Z+elYIisOX3eFZ9cuo4fkODnry+vQNkYuOn/mFe0sVxoBK+oqSl5
/tN7pTFB2CaSBnRrNHquEc6YFoglCjQW4fXzHdQCdx5B7oOg/yloIst2WagXbyvE
zQvWKm6jjB5/xdT5mpxHB/lanSZMGXFnITh8qXrlTxd/tSa3ic6+k1WC++5brUvE
MtldUnSV++fZh9C4xsXyi26ytr2KkwcJcXQbU2PF4iuV6L0eYO2xOgpDCoQ=
-----END CERTIFICATE-----"""
key_string = """-----BEGIN PRIVATE KEY-----
MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDrJNil62fkNm1j
UgEZ33hg5qYiLeNOEUgKaINCqhfQDuH7tTho+nRNxY2FSpv7ooyMckLYojNm+XEl
lUREE8hgIBiBWgiXazvoaxKFW2BIm7kpfxSC0t4pxwjehftm0Ny/nvms6SiE0ruL
3u+oUI9VVvgofra7mvhX3OZuZNb2QADaPnmyfB8VYGfzYAl0QgyFkrWzPflb/UXD
LdIP/niTpUHMgDTChQ+jf3tHm0pbsRZTxXISJY2+O5qpEgumW+Qcw5sKpjdfMYvH
hoM0IzMofBSfmQCZOjJRcisVLTASj5qN5+GFJi6Pz7oih203Ur8elq+iA0hRisA7
g37LNGXTAgMBAAECggEASMRxSv9LekMhnN/OuWv/e7VE6kTbF9ifO6FWJXYvwlIo
utU87Le88ChXgE0zci6+YeQmLZYcZByDWEcWBh89Hgowqy7qg7lKo8UmySAa7r1K
Er5h4Y5R9AnFA9/gidPOzHns+AZ7ZIc2RLWr4qFzicxNJXL5J5twiPgyUy1fnHpg
Ktk3ccgtIe8IJNYS9hGW40X6DZfbiNqnUlGxS0Nsk7RQhEowcuAob7sBf2k6tSAx
qaaB3PYBwGsfgF6Zkq81/ZmzZPoD0vSLURAlglTWgGljqXOqXVnqUFbcyaZeKwqX
4b5MlQMZ09puOz5CGG0HhnTFmt+N1rU3Vsx74G5hWQKBgQD4wHt9WL6DQPQ2/i0l
o6afSd0+DV5HldHGCRt4aF3//bGU3OugNvHVK2ijXEUIDHcpvEW1vwjbqmkFI3Sn
wANCr8YAmu/51uYYyeUP4V35SKBtBBdhUvFOGE3MThJQusAdEYg65T9STQvmpRnJ
Yv5QRlX/jawEtS2H9pZo+WvZpQKBgQDx/tuiU2isBfOrT5MAVxtu/VEZvafwRcHe
0EmRCyW6+rHSA3o2/3f43t6x63qvvk6NYY9rSz/0TZkZ/Y3QihPNqGwGuuzSvsG+
yDfnv6YmtcnBPv2kXHwEeIsd9DdjqT4D3MIHGHo05cu9Ta7oTHVAo8OSQbEqkGwj
oYpuQTz4FwKBgQCxuo1A9OxByWHz/M1zDCdbviHGWTTYftH/5bfr4t3urmt4ChSM
R1WoUjiUJ7Pm2Uk2158TCSgiEvKwSjHqPUXXGtGk0w7M+l8yrOXt378OAnclDPxL
fECO5MyJQerSJWxoGIO2WN9SRVxQcfwnqIQ+BNMjIS0bu/uJHoU/AZ6uRQKBgQC5
FT9Oa5TG3NZ806OOwxCMVtpMYa2sKu4YSB27/VaiJ1MRWO+EWOedRHf2hC+VcmwJ
3fAfE7KaWy8Znb91G+YBiSr2CslOde8gx2laqk2dlbP1RQQhTUrc8IUWJ86lPq/b
rGAJpULyaj7lTiDUMoYLJjVSC0RBVawfpFGH+gVziQKBgQDI+dgmgFv3ULUUTBtP
iPwYrGFWmzcKwevPaIQqrsjJ0TY2INmQZi6pn4ogelUtcRMFjzpBGHrsxJM0RkSy
3A855c5gfp60XOQB3ab0OS0X5/gzDZHThN7wvspUFnZ9i6LhSEOHMEAxwSklCtPq
m4DpuP4nL0ixQJWZuV+qrx6Tow==
-----END PRIVATE KEY-----"""
return (cert_string, key_string)
def check_cert_equal(self, first, second):
if isinstance(first, crypto.X509):
first_string = crypto.dump_certificate(crypto.FILETYPE_PEM, first)
else:
first_string = first
second_string = crypto.dump_certificate(crypto.FILETYPE_PEM, second)
return first_string == second_string
def check_key_equal(self, first, second):
if isinstance(first, crypto.PKey):
first_string = crypto.dump_privatekey(crypto.FILETYPE_PEM, first)
else:
first_string = first
second_string = crypto.dump_privatekey(crypto.FILETYPE_PEM, second)
return first_string == second_string
def check_csr_equal(self, first, second):
if isinstance(first, crypto.X509Req):
first_string = crypto.dump_certificate_request(crypto.FILETYPE_PEM, first)
else:
first_string = first
second_string = crypto.dump_certificate_request(crypto.FILETYPE_PEM, second)
return first_string == second_string
def tearDown(self):
db.session.remove()
db.drop_all()
if os.path.exists(self.ca_dir):
shutil.rmtree(self.ca_dir)
def test_createCAKeyPair(self):
# initials keypair are generated when instanciating ca
ca = self.make_ca(160)
self.assertEquals(len(ca._ca_key_pairs_list), 1)
def renewCAKetPair(self):
ca = self.make_ca(2)
self.assertEquals(len(ca._ca_key_pairs_list), 1)
first = ca._ca_key_pairs_list
# No renew possible
self.assertFalse(ca.renewCAKeyPair())
time.sleep(5)
# ca Certificate should be renewed
self.assertTrue(ca.renewCAKeyPair())
self.assertEquals(len(ca._ca_key_pairs_list), 2)
self.assertTrue(self.check_cert_equal(ca._ca_key_pairs_list[0]['crt'], first['crt']))
self.assertTrue(self.check_key_equal(ca._ca_key_pairs_list[0]['key'], first['key']))
def test_getPendingCertificateRequest(self):
ca = self.make_ca(190)
csr, key = self.generateCSR()
csr_string = self.csr_tostring(csr)
csr_id = ca.createCertificateSigningRequest(csr_string)
stored = ca.getPendingCertificateRequest(csr_id)
self.assertEquals(csr_string, stored)
def test_deletePendingCertificateRequest(self):
ca = self.make_ca(190)
csr, key = self.generateCSR()
csr_string = self.csr_tostring(csr)
csr_id = ca.createCertificateSigningRequest(csr_string)
stored = ca.getPendingCertificateRequest(csr_id)
self.assertEquals(csr_string, stored)
ca.deletePendingCertificateRequest(csr_id)
with self.assertRaises(NotFound):
ca.getPendingCertificateRequest(csr_id)
def test_createCertificate(self):
ca = self.make_ca(190)
csr, key = self.generateCSR()
csr_id = ca.createCertificateSigningRequest(self.csr_tostring(csr))
# sign certificate with default ca keypair
cert_id = ca.createCertificate(csr_id)
cert = ca.getCertificate(cert_id)
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
self.assertTrue(utils.validateCertAndKey(x509, key))
subj_dict = {'CN': 'toto.example.com',
'C': 'CC',
'ST': 'ST',
'L': 'LOU',
'O': 'OOU',
'OU': 'OU',
'emailAddress': 'toto@example.com'}
for attr in ['C', 'ST', 'L', 'OU', 'O', 'CN', 'emailAddress']:
self.assertEqual(getattr(x509.get_subject(), attr), subj_dict[attr])
with self.assertRaises(NotFound):
ca.getPendingCertificateRequest(csr_id)
def test_createCertificate_custom_subject(self):
ca = self.make_ca(190)
csr, key = self.generateCSR(cn="test certificate", email="some@test.com")
csr_id = ca.createCertificateSigningRequest(self.csr_tostring(csr))
# sign certificate with default ca keypair
subject_dict = dict(CN="real cn", emailAddress="caucase@email.com")
# sign certificate but change subject
cert_id = ca.createCertificate(csr_id, subject_dict=subject_dict)
cert = ca.getCertificate(cert_id)
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
self.assertTrue(utils.validateCertAndKey(x509, key))
self.assertEqual(x509.get_subject().CN, subject_dict['CN'])
self.assertEqual(x509.get_subject().emailAddress, subject_dict['emailAddress'])
# Others attributes are empty
for attr in ['C', 'ST', 'L', 'OU', 'O']:
self.assertEqual(getattr(x509.get_subject(), attr), None)
with self.assertRaises(NotFound):
ca.getPendingCertificateRequest(csr_id)
def test_createCertificate_custom_subject2(self):
ca = self.make_ca(190)
csr, key = self.generateCSR(cn="test certificate", email="some@test.com")
csr_id = ca.createCertificateSigningRequest(self.csr_tostring(csr))
subject_dict = {'CN': 'some.site.com',
'C': 'FR',
'O': 'My Organisation',
'L': 'Localisation',
'OU': 'Organisation U',
'ST': 'State',
'emailAddress': 'toto@example.com'}
# sign certificate but change subject
cert_id = ca.createCertificate(csr_id, subject_dict=subject_dict)
cert = ca.getCertificate(cert_id)
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
# certificate is still valid
self.assertTrue(utils.validateCertAndKey(x509, key))
# check that all attributes are set
for attr in ['C', 'ST', 'L', 'OU', 'O']:
self.assertEqual(getattr(x509.get_subject(), attr), subject_dict[attr])
with self.assertRaises(NotFound):
ca.getPendingCertificateRequest(csr_id)
def test_createCertificate_custom_subject_no_cn(self):
ca = self.make_ca(190)
csr, key = self.generateCSR(cn="test certificate", email="some@test.com")
csr_id = ca.createCertificateSigningRequest(self.csr_tostring(csr))
subject_dict = dict(C="FR", emailAddress="caucase@email.com")
# CN is missing, will raise
with self.assertRaises(AttributeError):
ca.createCertificate(csr_id, subject_dict=subject_dict)
def test_getCAKeypairForCertificate(self):
csr, key = self.generateCSR()
ca = self.make_ca(3)
csr_id = ca.createCertificateSigningRequest(self.csr_tostring(csr))
# sign certificate with default ca keypair
cert_id = ca.createCertificate(csr_id)
cert = ca.getCertificate(cert_id)
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
self.assertTrue(utils.validateCertAndKey(x509, key))
cert_keypair = ca._ca_key_pairs_list[0]
# 2 crt_life_time cycles + 1s
time.sleep(7)
# Create new CA keypair
self.assertTrue(ca.renewCAKeyPair())
# get keypair which should be used to renew this cert
calculated = ca.getCAKeypairForCertificate(x509)
self.assertTrue(self.check_cert_equal(cert_keypair['crt'], calculated['crt']))
self.assertTrue(self.check_key_equal(cert_keypair['key'], calculated['key']))
self.assertEquals(len(ca._ca_key_pairs_list), 2)
new_keypair = ca._ca_key_pairs_list[-1]
time.sleep(3)
# the first ca keypair cannot be used to renew cert (7+3 -12 = 2 < crt_life_time)
calculated = ca.getCAKeypairForCertificate(x509)
self.assertTrue(self.check_cert_equal(new_keypair['crt'], calculated['crt']))
self.assertTrue(self.check_key_equal(new_keypair['key'], calculated['key']))
def test_renewCertificate(self):
ca = self.make_ca(158)
csr, key = self.generateCSR()
csr_string = self.csr_tostring(csr)
csr_id = ca.createCertificateSigningRequest(csr_string)
# sign certificate with default ca keypair
cert_id = ca.createCertificate(csr_id)
cert = ca.getCertificate(cert_id)
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
self.assertTrue(utils.validateCertAndKey(x509, key))
payload = dict(
renew_csr=csr_string,
crt=cert
)
wrapped = utils.wrap(payload, crypto.dump_privatekey(crypto.FILETYPE_PEM, key), [self.default_digest])
new_csr_id = ca.renew(wrapped)
new_cert_id = '%s.crt.pem' % new_csr_id[:-8]
new_cert = ca.getCertificate(new_cert_id)
new_x509 = crypto.load_certificate(crypto.FILETYPE_PEM, new_cert)
self.assertTrue(utils.validateCertAndKey(new_x509, key))
self.assertEquals(new_x509.get_subject().CN, x509.get_subject().CN)
# current certificate is not revoked
self.assertTrue(utils.validateCertAndKey(x509, key))
def test_renewCertificate_bad_cert(self):
ca = self.make_ca(158)
csr, key = self.generateCSR()
csr_string = self.csr_tostring(csr)
csr_id = ca.createCertificateSigningRequest(csr_string)
# sign certificate with default ca keypair
cert_id = ca.createCertificate(csr_id)
cert = ca.getCertificate(cert_id)
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
self.assertTrue(utils.validateCertAndKey(x509, key))
# second certificate
csr2, key2 = self.generateCSR()
csr_id2 = ca.createCertificateSigningRequest(self.csr_tostring(csr2))
cert_id2 = ca.createCertificate(csr_id2)
cert2 = ca.getCertificate(cert_id2)
x509_2 = crypto.load_certificate(crypto.FILETYPE_PEM, cert2)
self.assertTrue(utils.validateCertAndKey(x509_2, key2))
payload = dict(
renew_csr=csr_string,
crt=cert
)
# sign with bad key
wrapped = utils.wrap(payload, crypto.dump_privatekey(crypto.FILETYPE_PEM, key2), [self.default_digest])
with self.assertRaises(BadSignature):
ca.renew(wrapped)
# payload with invalid PEM certificate
payload = dict(
renew_csr=csr_string,
crt="BAD PEM CERTIFICATE"
)
wrapped = utils.wrap(payload, crypto.dump_privatekey(crypto.FILETYPE_PEM, key), [self.default_digest])
with self.assertRaises(BadSignature):
ca.renew(wrapped)
# payload with invalid PEM certificate request content
payload = dict(
renew_csr="BAD PEM CERTIFICATE REQUEST",
crt=cert
)
wrapped = utils.wrap(payload, crypto.dump_privatekey(crypto.FILETYPE_PEM, key), [self.default_digest])
with self.assertRaises(BadCertificateSigningRequest):
ca.renew(wrapped)
# payload with Fake certificate
fcert, fkey = self.get_fake_cert_key()
payload = dict(
renew_csr=csr_string,
crt=cert
)
wrapped = utils.wrap(payload, fkey, [self.default_digest])
with self.assertRaises(BadSignature):
ca.renew(wrapped)
payload = dict(
renew_csr=csr_string,
crt=fcert
)
wrapped = utils.wrap(payload, fkey, [self.default_digest])
with self.assertRaises(BadCertificateSigningRequest):
# Fake certificate and renew_csr has not the same csr
ca.renew(wrapped)
def test_revokeCertificate(self):
ca = self.make_ca(158)
csr, key = self.generateCSR()
csr_id = ca.createCertificateSigningRequest(self.csr_tostring(csr))
# sign certificate with default ca keypair
cert_id = ca.createCertificate(csr_id)
cert = ca.getCertificate(cert_id)
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
self.assertTrue(utils.validateCertAndKey(x509, key))
payload = dict(
reason='',
revoke_crt=cert
)
wrapped = utils.wrap(payload, crypto.dump_privatekey(crypto.FILETYPE_PEM, key), [self.default_digest])
ca.revokeCertificate(wrapped)
with self.assertRaises(NotFound):
ca.getCertificate(cert_id)
revocation_list = self._storage.getRevocationList()
self.assertEquals(len(revocation_list), 1)
self.assertEquals(revocation_list[0].serial, utils.getSerialToInt(x509))
def test_revokeCertificate_expired(self):
ca = self.make_ca(2)
csr, key = self.generateCSR()
csr_id = ca.createCertificateSigningRequest(self.csr_tostring(csr))
# sign certificate with default ca keypair
cert_id = ca.createCertificate(csr_id)
cert = ca.getCertificate(cert_id)
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
self.assertTrue(utils.validateCertAndKey(x509, key))
# wait until certificate expire
time.sleep(3)
payload = dict(
reason='',
revoke_crt=cert
)
wrapped = utils.wrap(payload, crypto.dump_privatekey(crypto.FILETYPE_PEM, key), [self.default_digest])
with self.assertRaises(CertificateVerificationError):
# if certificate expire, verification fail
ca.revokeCertificate(wrapped)
def test_revokeCertificate_bad_cert(self):
ca = self.make_ca(158)
csr, key = self.generateCSR()
csr_id = ca.createCertificateSigningRequest(self.csr_tostring(csr))
# sign certificate with default ca keypair
cert_id = ca.createCertificate(csr_id)
cert = ca.getCertificate(cert_id)
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
self.assertTrue(utils.validateCertAndKey(x509, key))
# second certificate
csr2, key2 = self.generateCSR()
csr_id2 = ca.createCertificateSigningRequest(self.csr_tostring(csr2))
cert_id2 = ca.createCertificate(csr_id2)
cert2 = ca.getCertificate(cert_id2)
x509_2 = crypto.load_certificate(crypto.FILETYPE_PEM, cert2)
self.assertTrue(utils.validateCertAndKey(x509_2, key2))
payload = dict(
reason="",
revoke_crt=cert
)
# sign with bad key
wrapped = utils.wrap(payload, crypto.dump_privatekey(crypto.FILETYPE_PEM, key2), [self.default_digest])
with self.assertRaises(BadSignature):
ca.revokeCertificate(wrapped)
# payload with invalid PEM certificate
payload = dict(
reason="",
revoke_crt="BAD PEM CERTIFICATE"
)
wrapped = utils.wrap(payload, crypto.dump_privatekey(crypto.FILETYPE_PEM, key), [self.default_digest])
with self.assertRaises(BadSignature):
ca.revokeCertificate(wrapped)
# payload with Fake certificate
fcert, fkey = self.get_fake_cert_key()
payload = dict(
reason="",
revoke_crt=cert
)
wrapped = utils.wrap(payload, fkey, [self.default_digest])
with self.assertRaises(BadSignature):
ca.revokeCertificate(wrapped)
payload = dict(
reason="",
revoke_crt=fcert
)
wrapped = utils.wrap(payload, fkey, [self.default_digest])
with self.assertRaises(CertificateVerificationError):
ca.revokeCertificate(wrapped)
def test_getCertificateRevocationList(self):
ca = self.make_ca(158)
def signcert():
csr, key = self.generateCSR()
csr_id = ca.createCertificateSigningRequest(self.csr_tostring(csr))
# sign certificate with default ca keypair
cert_id = ca.createCertificate(csr_id)
cert = ca.getCertificate(cert_id)
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
self.assertTrue(utils.validateCertAndKey(x509, key))
return x509, key
cert_1, key_1 = signcert()
cert_2, key_2 = signcert()
cert2_string = crypto.dump_certificate(crypto.FILETYPE_PEM, cert_2)
cert_3, key_3 = signcert()
cert3_string = crypto.dump_certificate(crypto.FILETYPE_PEM, cert_3)
cert_4, key_4 = signcert()
crl = ca.getCertificateRevocationList()
crl_obj = crypto.load_crl(crypto.FILETYPE_PEM, crl)
self.assertEquals(crl_obj.get_revoked(), None)
payload = dict(
reason="",
revoke_crt=cert2_string
)
# sign with bad key
wrapped = utils.wrap(payload, crypto.dump_privatekey(crypto.FILETYPE_PEM, key_2), [self.default_digest])
ca.revokeCertificate(wrapped)
crl2_string = ca.getCertificateRevocationList()
crl2 = crypto.load_crl(crypto.FILETYPE_PEM, crl2_string)
self.assertEquals(len(crl2.get_revoked()), 1)
serial = utils.getSerialToInt(cert_2)
self.assertEquals(crl2.get_revoked()[0].get_serial(), serial.upper())
payload = dict(
reason="",
revoke_crt=cert3_string
)
# sign with bad key
wrapped = utils.wrap(payload, crypto.dump_privatekey(crypto.FILETYPE_PEM, key_3), [self.default_digest])
ca.revokeCertificate(wrapped)
crl3_string = ca.getCertificateRevocationList()
crl3 = crypto.load_crl(crypto.FILETYPE_PEM, crl3_string)
self.assertEquals(len(crl3.get_revoked()), 2)
matches = 0
for revoked in crl3.get_revoked():
if revoked.get_serial() == utils.getSerialToInt(cert_3).upper():
matches += 1
elif revoked.get_serial() == utils.getSerialToInt(cert_2).upper():
matches += 1
self.assertEquals(matches, 2)
crl4_string = ca.getCertificateRevocationList()
# nothing changed, crl not expired
self.assertEquals(crl3_string, crl4_string)
def test_getCertificateRevocationList_with_expire(self):
ca = self.make_ca(2)
def signcert():
csr, key = self.generateCSR()
csr_id = ca.createCertificateSigningRequest(self.csr_tostring(csr))
# sign certificate with default ca keypair
cert_id = ca.createCertificate(csr_id)
cert = ca.getCertificate(cert_id)
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
self.assertTrue(utils.validateCertAndKey(x509, key))
return x509, key
cert_1, key_1 = signcert()
cert_2, key_2 = signcert()
cert2_string = crypto.dump_certificate(crypto.FILETYPE_PEM, cert_2)
crl_string = ca.getCertificateRevocationList()
crl = crypto.load_crl(crypto.FILETYPE_PEM, crl_string)
self.assertEquals(crl.get_revoked(), None)
payload = dict(
reason="",
revoke_crt=cert2_string
)
# sign with bad key
wrapped = utils.wrap(payload, crypto.dump_privatekey(crypto.FILETYPE_PEM, key_2), [self.default_digest])
ca.revokeCertificate(wrapped)
crl2_string = ca.getCertificateRevocationList()
crl2 = crypto.load_crl(crypto.FILETYPE_PEM, crl2_string)
self.assertEquals(len(crl2.get_revoked()), 1)
serial = utils.getSerialToInt(cert_2)
self.assertEquals(crl2.get_revoked()[0].get_serial(), serial.upper())
# wait until cert_2 expire
time.sleep(3)
cert_3, key_3 = signcert()
cert3_string = crypto.dump_certificate(crypto.FILETYPE_PEM, cert_3)
payload = dict(
reason="",
revoke_crt=cert3_string
)
# sign with bad key
wrapped = utils.wrap(payload, crypto.dump_privatekey(crypto.FILETYPE_PEM, key_3), [self.default_digest])
ca.revokeCertificate(wrapped)
crl3_string = ca.getCertificateRevocationList()
crl3 = crypto.load_crl(crypto.FILETYPE_PEM, crl3_string)
# cert_2 is not longer into crl (expired)
self.assertEquals(len(crl3.get_revoked()), 1)
serial = utils.getSerialToInt(cert_3)
self.assertEquals(crl3.get_revoked()[0].get_serial(), serial.upper())
def test_getCertificateRevocationList_with_validation(self):
ca = self.make_ca(158)
def signcert():
csr, key = self.generateCSR()
csr_id = ca.createCertificateSigningRequest(self.csr_tostring(csr))
# sign certificate with default ca keypair
cert_id = ca.createCertificate(csr_id)
cert = ca.getCertificate(cert_id)
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
self.assertTrue(utils.validateCertAndKey(x509, key))
return x509, key
cert_1, key_1 = signcert()
cert_2, key_2 = signcert()
cert2_string = crypto.dump_certificate(crypto.FILETYPE_PEM, cert_2)
cert_3, key_3 = signcert()
payload = dict(
reason="",
revoke_crt=cert2_string
)
# sign with bad key
wrapped = utils.wrap(payload, crypto.dump_privatekey(crypto.FILETYPE_PEM, key_2), [self.default_digest])
ca.revokeCertificate(wrapped)
crl_string = ca.getCertificateRevocationList()
crl = crypto.load_crl(crypto.FILETYPE_PEM, crl_string)
self.assertEquals(len(crl.get_revoked()), 1)
serial = utils.getSerialToInt(cert_2)
self.assertEquals(crl.get_revoked()[0].get_serial(), serial.upper())
with self.assertRaises(CertificateVerificationError):
utils.verifyCertificateChain(cert_2,
[x['crt'] for x in ca._ca_key_pairs_list], crl)
utils.verifyCertificateChain(cert_3,
[x['crt'] for x in ca._ca_key_pairs_list], crl)
utils.verifyCertificateChain(cert_1,
[x['crt'] for x in ca._ca_key_pairs_list], crl)
# This file is part of caucase
# Copyright (C) 2017 Nexedi
# Alain Takoudjou <alain.takoudjou@nexedi.com>
# Vincent Pelletier <vincent@nexedi.com>
#
# caucase is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# caucase is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
import os, time
import shutil
import tempfile
import unittest
import json
from datetime import datetime, timedelta
from caucase import app, db
from caucase.storage import Storage, Config
from OpenSSL import crypto, SSL
from caucase.exceptions import (NoStorage, NotFound, Found)
from sqlite3 import IntegrityError
from caucase import utils
import uuid
class StorageTest(unittest.TestCase):
def setUp(self):
self.ca_dir = tempfile.mkdtemp()
self.db_file = os.path.join(self.ca_dir, 'ca.db')
#os.mkdir(self.ca_dir)
self.max_request_amount = 3
self.default_digest = "sha256"
app.config.update(
DEBUG=True,
CSRF_ENABLED=True,
SECRET_KEY = 'This is an UNSECURE Secret. Please CHANGE THIS for production environments.',
TESTING=True,
SQLALCHEMY_DATABASE_URI='sqlite:///%s' % self.db_file
)
self._storage = Storage(db)
def setConfig(self, key, value):
entry = self._storage._getConfig(key)
if not entry:
entry = Config(key=key, value='%s' % value)
db.session.add(entry)
else:
# update value
entry.value = value
db.session.commit()
def tearDown(self):
db.session.remove()
db.drop_all()
if os.path.exists(self.ca_dir):
shutil.rmtree(self.ca_dir)
def createCAKeyPair(self, life_time=60):
key_pair = {}
key = crypto.PKey()
# Use 2048 bits key size
key.generate_key(crypto.TYPE_RSA, 2048)
key_pair['key'] = key
ca = crypto.X509()
ca.set_version(3)
ca.set_serial_number(int(time.time()))
ca.get_subject().CN = "CA Cert %s" % int(time.time())
ca.get_subject().C = "FR"
ca.get_subject().ST = "XX"
ca.get_subject().O = "ORG"
ca.get_subject().OU = "OU"
ca.get_subject().L = "LL"
ca.get_subject().emailAddress = "xxx@exemple.com"
ca.gmtime_adj_notBefore(0)
ca.gmtime_adj_notAfter(life_time)
ca.set_issuer(ca.get_subject())
ca.set_pubkey(key)
utils.X509Extension().setCaExtensions(ca)
ca.sign(key, self.default_digest)
key_pair['crt'] = ca
return key_pair
def generateCSR(self, cn="toto.example.com"):
key = crypto.PKey()
key.generate_key(crypto.TYPE_RSA, 2048)
req = crypto.X509Req()
subject = req.get_subject()
subject.CN = cn
subject.C = "CC"
subject.ST = "ST"
subject.L = "LL"
subject.O = "ORG"
subject.OU = "OU"
subject.emailAddress = "toto@example.com"
req.set_pubkey(key)
utils.X509Extension().setDefaultCsrExtensions(req)
req.sign(key, self.default_digest)
return (req, key)
def createCertificate(self, ca_key_pair, req, expire_sec=180):
serial = uuid.uuid1().int
cert = crypto.X509()
# 3 = v3
cert.set_version(3)
cert.set_serial_number(serial)
cert.gmtime_adj_notBefore(0)
cert.gmtime_adj_notAfter(expire_sec)
cert.set_issuer(ca_key_pair['crt'].get_subject())
cert.set_subject(req.get_subject())
cert.set_pubkey(req.get_pubkey())
utils.X509Extension().setDefaultExtensions(
cert,
subject=cert,
issuer=ca_key_pair['crt'],
crl_url="http://ca.crl.com")
cert.sign(ca_key_pair['key'], self.default_digest)
return cert
def generateCRL(self, ca_key_pair, revocation_list, version_number):
now = datetime.now()
crl = crypto.CRL()
num_crl_days = 1
for revocation in revocation_list:
revoked = crypto.Revoked()
revoked.set_rev_date(
revocation.creation_date.strftime("%Y%m%d%H%M%SZ").encode("ascii")
)
revoked.set_serial(revocation.serial.encode("ascii"))
revoked.set_reason(None) #b'%s' % revocation.reason)
crl.add_revoked(revoked)
crl.set_version(version_number)
# XXX - set how to get the cacert here
cert = ca_key_pair['crt']
key = ca_key_pair['key']
return crypto.load_crl(
crypto.FILETYPE_PEM,
crl.export(
cert,
key,
type=crypto.FILETYPE_PEM,
days=num_crl_days,
digest=self.default_digest)
)
def check_cert_equal(self, first, second):
if isinstance(first, crypto.X509):
first_string = crypto.dump_certificate(crypto.FILETYPE_PEM, first)
else:
first_string = first
second_string = crypto.dump_certificate(crypto.FILETYPE_PEM, second)
return first_string == second_string
def check_key_equal(self, first, second):
if isinstance(first, crypto.PKey):
first_string = crypto.dump_privatekey(crypto.FILETYPE_PEM, first)
else:
first_string = first
second_string = crypto.dump_privatekey(crypto.FILETYPE_PEM, second)
return first_string == second_string
def check_csr_equal(self, first, second):
if isinstance(first, crypto.X509Req):
first_string = crypto.dump_certificate_request(crypto.FILETYPE_PEM, first)
else:
first_string = first
second_string = crypto.dump_certificate_request(crypto.FILETYPE_PEM, second)
return first_string == second_string
def test_db_exists(self):
self.assertTrue(os.path.exists(self.db_file))
def test_config(self):
# no config exists
self.assertEquals(self._storage.getConfig('config-sample'), None)
# with default value
self.assertEquals(self._storage.getConfig('config-sample', "tototo"), "tototo")
# set config (stored as string)
self.setConfig('config-test', 1458)
self.setConfig('test-dict', dict(first=23, second="sec"))
# values are string
self.assertEquals(self._storage.getConfig('config-test'), "1458")
self.assertEquals(self._storage.getConfig('test-dict'), str(dict(first=23, second="sec")))
def test_store_CAKeypair(self):
keypair = self.createCAKeyPair()
self._storage.storeCAKeyPair(keypair)
# check stored keypair
stored = self._storage.getCAKeyPairList()
self.assertEquals(len(stored), 1)
self.assertTrue(self.check_cert_equal(stored[0]['crt'], keypair['crt']))
self.assertTrue(self.check_key_equal(stored[0]['key'], keypair['key']))
def test_store_same_keypair(self):
keypair = self.createCAKeyPair()
self._storage.storeCAKeyPair(keypair)
# check stored keypair
stored = self._storage.getCAKeyPairList()
self.assertEquals(len(stored), 1)
self.assertTrue(self.check_cert_equal(stored[0]['crt'], keypair['crt']))
self.assertTrue(self.check_key_equal(stored[0]['key'], keypair['key']))
# store again the same keypair
with self.assertRaises(Found):
self._storage.storeCAKeyPair(keypair)
def test_store_keypair_multiple(self):
keypair = self.createCAKeyPair()
self._storage.storeCAKeyPair(keypair)
# check stored keypair
stored = self._storage.getCAKeyPairList()
self.assertEquals(len(stored), 1)
self.assertTrue(self.check_cert_equal(stored[0]['crt'], keypair['crt']))
self.assertTrue(self.check_key_equal(stored[0]['key'], keypair['key']))
time.sleep(1)
keypair2 = self.createCAKeyPair()
self._storage.storeCAKeyPair(keypair2)
stored2 = self._storage.getCAKeyPairList()
self.assertEquals(len(stored2), 2)
# check that order of keypair is good
first = stored2[0]
self.assertTrue(self.check_cert_equal(first['crt'], keypair['crt']))
self.assertTrue(self.check_key_equal(first['key'], keypair['key']))
second = stored2[1]
self.assertTrue(self.check_cert_equal(second['crt'], keypair2['crt']))
self.assertTrue(self.check_key_equal(second['key'], keypair2['key']))
def test_storeCertificateSigningRequest(self):
csr, key = self.generateCSR()
csr_id = self._storage.storeCertificateSigningRequest(csr)
stored = self._storage.getPendingCertificateRequest(csr_id)
self.assertTrue(self.check_csr_equal(stored, csr))
def test_deletePendingCertificateRequest(self):
csr, key = self.generateCSR()
csr_id = self._storage.storeCertificateSigningRequest(csr)
stored = self._storage.getPendingCertificateRequest(csr_id)
self.assertTrue(self.check_csr_equal(stored, csr))
self._storage.deletePendingCertificateRequest(csr_id)
with self.assertRaises(NotFound):
self._storage.getPendingCertificateRequest(csr_id)
def test_storeCertificateSigningRequest_no_storage(self):
self.setConfig('max-csr-amount', self.max_request_amount)
self.assertEquals(int(self._storage.getConfig('max-csr-amount')), self.max_request_amount)
for i in range(0, self.max_request_amount):
csr, _ = self.generateCSR()
self._storage.storeCertificateSigningRequest(csr)
# will raise NoStorage now
csr, _ = self.generateCSR()
with self.assertRaises(NoStorage):
self._storage.storeCertificateSigningRequest(csr)
csr_list = self._storage.getPendingCertificateRequestList()
self.assertEquals(len(csr_list), self.max_request_amount)
def store_storeCertificateSigningRequest_same(self):
csr, key = self.generateCSR()
csr_id = self._storage.storeCertificateSigningRequest(csr)
stored = self._storage.getPendingCertificateRequest(csr_id)
self.assertTrue(self.check_csr_equal(stored, csr))
# store a second time the same csr
csr2_id = self._storage.storeCertificateSigningRequest(csr)
self.assertEquals(csr2_id, csr_id)
stored2 = self._storage.getPendingCertificateRequest(csr2_id)
self.assertEquals(stored2, stored)
csr_list = self._storage.getPendingCertificateRequestList()
# there is only on csr in the list
self.assertEquals(len(csr_list), 1)
def test_storeCertificate(self):
keypair = self.createCAKeyPair()
self._storage.storeCAKeyPair(keypair)
csr, _ = self.generateCSR()
csr_id = self._storage.storeCertificateSigningRequest(csr)
cert = self.createCertificate(keypair, csr)
cert_id = self._storage.storeCertificate(csr_id, cert)
stored = self._storage.getCertificate(cert_id)
self.assertTrue(self.check_cert_equal(stored, cert))
def test_storeCertificate_wrong_csr(self):
keypair = self.createCAKeyPair()
self._storage.storeCAKeyPair(keypair)
csr, _ = self.generateCSR()
cert = self.createCertificate(keypair, csr)
csr_id="1234"
# csr_id not exists
with self.assertRaises(NotFound):
self._storage.storeCertificate(csr_id, cert)
csr_id = self._storage.storeCertificateSigningRequest(csr)
self._storage.deletePendingCertificateRequest(csr_id)
# csr was deleted
with self.assertRaises(NotFound):
self._storage.storeCertificate(csr_id, cert)
def test_storeCertificate_same(self):
keypair = self.createCAKeyPair()
self._storage.storeCAKeyPair(keypair)
csr, _ = self.generateCSR()
csr_id = self._storage.storeCertificateSigningRequest(csr)
cert = self.createCertificate(keypair, csr)
cert_id = self._storage.storeCertificate(csr_id, cert)
stored = self._storage.getCertificate(cert_id)
self.assertTrue(self.check_cert_equal(stored, cert))
with self.assertRaises(NotFound):
# CSR not found
self._storage.storeCertificate(csr_id, cert)
def test_storeCertificate_same_csr(self):
keypair = self.createCAKeyPair()
self._storage.storeCAKeyPair(keypair)
csr, _ = self.generateCSR()
csr_id = self._storage.storeCertificateSigningRequest(csr)
cert = self.createCertificate(keypair, csr)
cert_id = self._storage.storeCertificate(csr_id, cert)
stored = self._storage.getCertificate(cert_id)
self.assertTrue(self.check_cert_equal(stored, cert))
with self.assertRaises(NotFound):
# CSR not found
self._storage.storeCertificate(csr_id, cert)
csr2_id = self._storage.storeCertificateSigningRequest(csr)
self.assertNotEquals(csr2_id, csr_id)
#with self.assertRaises(IntegrityError):
# cannot store 2 certificate with same serial
# self._storage.storeCertificate(csr2_id, cert)
# can store new certificate, using a different csr2_id from csr
cert2 = self.createCertificate(keypair, csr)
cert2_id = self._storage.storeCertificate(csr2_id, cert2)
self.assertNotEquals(cert2_id, cert_id)
def test_revokeCertificate(self):
keypair = self.createCAKeyPair()
self._storage.storeCAKeyPair(keypair)
csr, _ = self.generateCSR()
csr_id = self._storage.storeCertificateSigningRequest(csr)
cert = self.createCertificate(keypair, csr)
cert_id = self._storage.storeCertificate(csr_id, cert)
expiration_date = datetime.strptime(cert.get_notAfter(), '%Y%m%d%H%M%SZ')
self._storage.revokeCertificate(utils.getSerialToInt(cert), expiration_date)
with self.assertRaises(NotFound):
# certificate was revoked
self._storage.getCertificate(cert_id)
revocation_list = self._storage.getRevocationList()
self.assertEquals(len(revocation_list), 1)
self.assertEquals(revocation_list[0].serial, utils.getSerialToInt(cert))
self.assertEquals(revocation_list[0].crt_expire_after, expiration_date)
def test_revokeCertificate_not_exists(self):
keypair = self.createCAKeyPair()
self._storage.storeCAKeyPair(keypair)
csr, _ = self.generateCSR()
csr_id = self._storage.storeCertificateSigningRequest(csr)
cert = self.createCertificate(keypair, csr)
cert_id = self._storage.storeCertificate(csr_id, cert)
expiration_date = datetime.strptime(cert.get_notAfter(), '%Y%m%d%H%M%SZ')
revocation_list = self._storage.getRevocationList()
self.assertEquals(revocation_list, [])
self._storage.revokeCertificate(utils.getSerialToInt(cert), expiration_date)
with self.assertRaises(NotFound):
# certificate was revoked
self._storage.revokeCertificate(utils.getSerialToInt(cert), expiration_date)
def test_storeCertificateRevocation_with_expired(self):
keypair = self.createCAKeyPair()
self._storage.storeCAKeyPair(keypair)
def store_cert(expire_sec):
csr, _ = self.generateCSR()
csr_id = self._storage.storeCertificateSigningRequest(csr)
cert = self.createCertificate(keypair, csr, expire_sec=expire_sec)
cert_id = self._storage.storeCertificate(csr_id, cert)
return cert_id, cert
id1, cert1 = store_cert(5)
id2, cert2 = store_cert(260)
id3, cert3 = store_cert(180)
expiration_date1 = datetime.strptime(cert1.get_notAfter(), '%Y%m%d%H%M%SZ')
expiration_date3 = datetime.strptime(cert3.get_notAfter(), '%Y%m%d%H%M%SZ')
self._storage.revokeCertificate(utils.getSerialToInt(cert1), expiration_date1)
self._storage.revokeCertificate(utils.getSerialToInt(cert3), expiration_date3)
revocation_list = self._storage.getRevocationList()
self.assertEquals(len(revocation_list), 2)
stored_cert = self._storage.getCertificate(id2)
self.assertTrue(self.check_cert_equal(stored_cert, cert2))
for i in [0, 1]:
if revocation_list[0].serial == utils.getSerialToInt(cert1):
self.assertEquals(revocation_list[0].crt_expire_after, expiration_date1)
revocation_list.pop(0)
elif revocation_list[0].serial == utils.getSerialToInt(cert3):
self.assertEquals(revocation_list[0].crt_expire_after, expiration_date3)
revocation_list.pop(0)
# All items was removed with pop(0)
self.assertEquals(revocation_list, [])
time.sleep(5)
revocation_list = self._storage.getRevocationList()
# revoked cert1 certificate has expired notAfter
self.assertEquals(len(revocation_list), 1)
self.assertEquals(revocation_list[0].serial, utils.getSerialToInt(cert3))
with self.assertRaises(NotFound):
self._storage.getCertificate(id1)
def test_getNextCRLVersionNumber(self):
serial = self._storage.getNextCRLVersionNumber()
self.assertEquals(serial, 1)
def test_storeCertificateRevocationList(self):
keypair = self.createCAKeyPair()
self._storage.storeCAKeyPair(keypair)
def store_cert(expire_sec):
csr, _ = self.generateCSR()
csr_id = self._storage.storeCertificateSigningRequest(csr)
cert = self.createCertificate(keypair, csr, expire_sec=expire_sec)
cert_id = self._storage.storeCertificate(csr_id, cert)
return cert_id, cert
id1, cert1 = store_cert(60)
id2, cert2 = store_cert(260)
id3, cert3 = store_cert(180)
expiration_date1 = datetime.strptime(cert1.get_notAfter(), '%Y%m%d%H%M%SZ')
expiration_date3 = datetime.strptime(cert3.get_notAfter(), '%Y%m%d%H%M%SZ')
self._storage.revokeCertificate(utils.getSerialToInt(cert1), expiration_date1)
self._storage.revokeCertificate(utils.getSerialToInt(cert3), expiration_date3)
revocation_list = self._storage.getRevocationList()
self.assertEquals(len(revocation_list), 2)
crl = self.generateCRL(keypair, revocation_list, 1)
self._storage.storeCertificateRevocationList(
crl,
expiration_date=(datetime.utcnow() + timedelta(0, 160))
)
stored = self._storage.getCertificateRevocationList()
self.assertNotEqual(stored, None)
crl_string = crypto.dump_crl(crypto.FILETYPE_PEM, crl)
self.assertEquals(crl_string, stored)
def test_getCertificateRevocationList_empty(self):
keypair = self.createCAKeyPair()
crl = self._storage.getCertificateRevocationList()
self.assertEqual(crl, None)
crl = self.generateCRL(keypair, [], 1)
self._storage.storeCertificateRevocationList(
crl,
expiration_date=(datetime.utcnow() + timedelta(0, 3))
)
stored = self._storage.getCertificateRevocationList()
self.assertNotEqual(stored, None)
crl_string = crypto.dump_crl(crypto.FILETYPE_PEM, crl)
self.assertEquals(crl_string, stored)
time.sleep(4)
stored = self._storage.getCertificateRevocationList()
# crl is not valid anymore
self.assertEqual(stored, None)
def test_housekeep(self):
from caucase.storage import CertificateRequest, Certificate, CAKeypair, CertificateRevocationList, Revocation
self.setConfig('crt-keep-time', 5)
self.setConfig('csr-keep-time', 5)
# ca cert expire after 4 seconds
keypair = self.createCAKeyPair(5)
self._storage.storeCAKeyPair(keypair)
time.sleep(1)
keypair2 = self.createCAKeyPair(15)
self._storage.storeCAKeyPair(keypair2)
self.assertEquals(len(self._storage.getCAKeyPairList()), 2)
def store_cert(expire_sec):
csr, _ = self.generateCSR()
csr_id = self._storage.storeCertificateSigningRequest(csr)
cert = self.createCertificate(keypair, csr, expire_sec=expire_sec)
cert_id = self._storage.storeCertificate(csr_id, cert)
return cert_id, cert
id1, cert1 = store_cert(4)
id2, cert2 = store_cert(4)
id3, cert3 = store_cert(8)
expiration_date1 = datetime.strptime(cert2.get_notAfter(), '%Y%m%d%H%M%SZ')
self._storage.revokeCertificate(utils.getSerialToInt(cert2), expiration_date1)
revocation_list = self._storage.getRevocationList()
self.assertEquals(len(revocation_list), 1)
crl = self.generateCRL(keypair, revocation_list, 2)
self._storage.storeCertificateRevocationList(
crl,
expiration_date=(datetime.utcnow() + timedelta(0, 4))
)
time.sleep(2)
id_4, cert4 = store_cert(10)
id_5, cert5 = store_cert(10)
expiration_date3 = datetime.strptime(cert4.get_notAfter(), '%Y%m%d%H%M%SZ')
self._storage.revokeCertificate(utils.getSerialToInt(cert4), expiration_date3)
revocation_list = self._storage.getRevocationList()
self.assertEquals(len(revocation_list), 2)
crl2 = self.generateCRL(keypair, revocation_list, 3)
self._storage.storeCertificateRevocationList(
crl,
expiration_date=(datetime.utcnow() + timedelta(0, 10))
)
time.sleep(3)
crl_list = CertificateRevocationList.query.filter().all()
self.assertEquals(len(crl_list), 2)
revocation_list = Revocation.query.filter().all()
self.assertEquals(len(revocation_list), 2)
self._storage.housekeep()
# One key_pair is expired
stored = self._storage.getCAKeyPairList()
self.assertEquals(len(stored), 1)
self.assertTrue(self.check_cert_equal(stored[0]['crt'], keypair2['crt']))
self.assertTrue(self.check_key_equal(stored[0]['key'], keypair2['key']))
csr_count = CertificateRequest.query.filter().count()
# 3 csr should be removed
self.assertEquals(csr_count, 2)
with self.assertRaises(NotFound):
self._storage.getCertificate(id1)
self._storage.getCertificate(id2)
self._storage.getCertificate(id3)
with self.assertRaises(NotFound):
# this certificate is revoked
self._storage.getCertificate(id_4)
# content still exists (keep-time not expired)
self._storage.getCertificate(id_5)
# certificate informations are not remove
cert_count = Certificate.query.filter().count()
self.assertEquals(cert_count, 5)
revocation_list = Revocation.query.filter().all()
self.assertEquals(len(revocation_list), 1)
self.assertTrue(revocation_list[0].serial == utils.getSerialToInt(cert4))
# one crl is removed
crl_list = CertificateRevocationList.query.filter().all()
self.assertEquals(len(crl_list), 1)
# This file is part of caucase
# Copyright (C) 2017 Nexedi
# Alain Takoudjou <alain.takoudjou@nexedi.com>
# Vincent Pelletier <vincent@nexedi.com>
#
# caucase is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# caucase is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
import os, time
import urllib2
import shutil
import tempfile
import json
from datetime import datetime
from caucase.web import parseArguments, configure_flask
from OpenSSL import crypto, SSL
from caucase.exceptions import (NoStorage, NotFound, Found)
from caucase import utils
from flask_testing import TestCase
from flask import url_for
class CertificateAuthorityWebTest(TestCase):
def setUp(self):
self.ca_dir = tempfile.mkdtemp()
configure_flask(parseArguments(['--ca-dir', self.ca_dir, '-s', '/CN=CA Auth Test/emailAddress=xx@example.com']))
def tearDown(self):
self.db.session.remove()
self.db.drop_all()
if os.path.exists(self.ca_dir):
shutil.rmtree(self.ca_dir)
def create_app(self):
from caucase import db, app
app.config['TESTING'] = True
app.config['LIVESERVER_PORT'] = 0
self.db = db
return app
def generateCSR(self, cn="toto.example.com"):
key = crypto.PKey()
key.generate_key(crypto.TYPE_RSA, 2048)
req = crypto.X509Req()
subject = req.get_subject()
subject.CN = cn
subject.C = "CC"
subject.ST = "ST"
subject.L = "LO"
subject.O = "ORG"
subject.OU = "OU"
subject.emailAddress = "toto@example.com"
req.set_pubkey(key)
utils.X509Extension().setDefaultCsrExtensions(req)
req.sign(key, 'sha256')
return (req, key)
def _init_password(self, password):
response = self.client.post('/admin/setpassword', data=dict(password=password),
follow_redirects=True)
self.assert200(response)
def test_get_crl(self):
response = self.client.get('/crl')
self.assert200(response)
crypto.load_crl(crypto.FILETYPE_PEM, response.data)
def test_put_csr(self):
csr, _ = self.generateCSR()
csr_string = crypto.dump_certificate_request(crypto.FILETYPE_PEM, csr)
data = dict(csr=csr_string)
response = self.client.put(url_for('request_cert'), data=data)
self.assertEquals(response.status_code, 201)
csr_key = response.headers['Location'].split('/')[-1]
# the first csr is signed and csr is no longer available
response2 = self.client.get('/csr/%s' % csr_key)
self.assert404(response2)
cert_url = '/crt/%s.crt.pem' % csr_key[:-8]
response3 = self.client.get(cert_url)
self.assert200(response3)
crypto.load_certificate(crypto.FILETYPE_PEM, response3.data)
# put another csr
csr2, _ = self.generateCSR()
csr2_string = crypto.dump_certificate_request(crypto.FILETYPE_PEM, csr)
response4 = self.client.put(url_for('request_cert'), data=dict(csr=csr2_string))
self.assertEquals(response4.status_code, 201)
csr_key = response4.headers['Location'].split('/')[-1]
# get csr will return the csr
response5 = self.client.get('/csr/%s' % csr_key)
self.assert200(response5)
# the certificate is not signed
cert_url = '/crt/%s.crt.pem' % csr_key[:-8]
response6 = self.client.get(cert_url)
self.assert404(response6)
self.assertEquals(response5.data, csr2_string)
def test_get_csr_notfound(self):
response = self.client.get('/csr/1234')
self.assert404(response)
# self.assertEquals(response.json['name'], 'FileNotFound'))
def test_get_cacert(self):
response = self.client.get('/crt/ca.crt.pem')
self.assert200(response)
crypto.load_certificate(crypto.FILETYPE_PEM, response.data)
......@@ -15,240 +15,396 @@
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
"""
Caucase - Certificate Authority for Users, Certificate Authority for SErvices
Small-ish functions needed in many places.
"""
from __future__ import absolute_import
from collections import defaultdict
import datetime
import json
import os
import time
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives.asymmetric import padding
import cryptography.exceptions
import pem
from .exceptions import CertificateVerificationError
DEFAULT_DIGEST_LIST = ('sha256', 'sha384', 'sha512')
DEFAULT_DIGEST = DEFAULT_DIGEST_LIST[0]
DEFAULT_DIGEST_CLASS = getattr(hashes, DEFAULT_DIGEST.upper())
# load-time sanity check
def _checkDefaultDigestsAvailable():
for x in DEFAULT_DIGEST_LIST:
getattr(hashes, x.upper())
_checkDefaultDigestsAvailable()
del _checkDefaultDigestsAvailable
_cryptography_backend = default_backend()
# Registration-less OID under 2.25 tree (aka uuid tree)
CAUCASE_OID_TOP = '2.25.285541874270823339875695650038637483517'
CAUCASE_OID_AUTO_SIGNED = CAUCASE_OID_TOP + '.0'
# Reserved for tests: no meaning, always stripped but never specificaly
# checked for in the code.
CAUCASE_OID_RESERVED = CAUCASE_OID_TOP + '.999'
_CAUCASE_OID_AUTO_SIGNED = x509.oid.ObjectIdentifier(CAUCASE_OID_AUTO_SIGNED)
CAUCASE_POLICY_INFORMATION_AUTO_SIGNED = x509.PolicyInformation(
_CAUCASE_OID_AUTO_SIGNED,
[
x509.UserNotice(
None,
'Auto-signed caucase certificate',
),
]
)
def isCertificateAutoSigned(crt):
"""
Checks whether given certificate was automatically signed by caucase.
from caucase.exceptions import BadSignature, CertificateVerificationError
from OpenSSL import crypto, SSL
from pyasn1.codec.der import encoder as der_encoder
from pyasn1.type import tag
from pyasn1_modules import rfc2459
class GeneralNames(rfc2459.GeneralNames):
"""
rfc2459 has wrong tagset.
"""
tagSet = tag.TagSet(
(),
tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 0),
)
class DistributionPointName(rfc2459.DistributionPointName):
"""
rfc2459 has wrong tagset.
"""
tagSet = tag.TagSet(
(),
tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 0),
)
class ExtensionType():
CRL_DIST_POINTS = "crlDistributionPoints"
BASIC_CONSTRAINTS = "basicConstraints"
KEY_USAGE = "keyUsage"
NS_CERT_TYPE = "nsCertType"
NS_COMMENT = "nsComment"
SUBJECT_KEY_ID = "subjectKeyIdentifier"
AUTH_KEY_ID = "authorityKeyIdentifier"
class X509Extension(object):
known_extension_list = [name for (attr, name) in vars(ExtensionType).items()
if attr.isupper()]
def setX509Extension(self, ext_type, critical, value, subject=None, issuer=None):
if not ext_type in self.known_extension_list:
raise ValueError('Extension type is not known from ExtensionType class')
if ext_type == ExtensionType.CRL_DIST_POINTS:
cdp = self._getCrlDistPointExt(value)
return crypto.X509Extension(
b'%s' % ext_type,
critical,
'DER:' + cdp.encode('hex'),
subject=subject,
issuer=issuer,
)
else:
return crypto.X509Extension(
ext_type,
critical,
value,
subject=subject,
issuer=issuer,
)
def _getCrlDistPointExt(self, cdp_list):
cdp = rfc2459.CRLDistPointsSyntax()
position = 0
for cdp_type, cdp_value in cdp_list:
cdp_entry = rfc2459.DistributionPoint()
general_name = rfc2459.GeneralName()
if not cdp_type in ['dNSName', 'directoryName', 'uniformResourceIdentifier']:
raise ValueError("crlDistributionPoints GeneralName '%s' is not valid" % cdp_type)
general_name.setComponentByName(cdp_type, cdp_value)
general_names = GeneralNames()
general_names.setComponentByPosition(0, general_name)
name = DistributionPointName()
name.setComponentByName('fullName', general_names)
cdp_entry.setComponentByName('distributionPoint', name)
cdp.setComponentByPosition(position, cdp_entry)
position += 1
return der_encoder.encode(cdp)
def setCaExtensions(self, cert_obj):
"""
extensions for default certificate
"""
cert_obj.add_extensions([
self.setX509Extension(ExtensionType.BASIC_CONSTRAINTS, True,
"CA:TRUE, pathlen:0"),
self.setX509Extension(ExtensionType.NS_COMMENT,
False, "OpenSSL CA Certificate"),
self.setX509Extension(ExtensionType.KEY_USAGE,
True, "keyCertSign, cRLSign"),
self.setX509Extension(ExtensionType.SUBJECT_KEY_ID,
False, "hash", subject=cert_obj),
])
cert_obj.add_extensions([
self.setX509Extension(ExtensionType.AUTH_KEY_ID,
False, "keyid:always,issuer", issuer=cert_obj)
])
def setDefaultExtensions(self, cert_obj, subject=None, issuer=None, crl_url=None):
"""
extensions for default certificate
"""
cert_obj.add_extensions([
self.setX509Extension(ExtensionType.BASIC_CONSTRAINTS, False, "CA:FALSE"),
self.setX509Extension(ExtensionType.NS_COMMENT,
False, "OpenSSL Generated Certificate"),
self.setX509Extension(ExtensionType.SUBJECT_KEY_ID,
False, "hash", subject=subject),
])
cert_obj.add_extensions([
self.setX509Extension(ExtensionType.AUTH_KEY_ID,
False, "keyid,issuer", issuer=issuer)
])
if crl_url:
cert_obj.add_extensions([
self.setX509Extension(ExtensionType.CRL_DIST_POINTS,
False, [("uniformResourceIdentifier", crl_url)])
])
def setDefaultCsrExtensions(self, cert_obj, subject=None, issuer=None):
"""
extensions for certificate signature request
"""
cert_obj.add_extensions([
self.setX509Extension(ExtensionType.BASIC_CONSTRAINTS, False, "CA:FALSE"),
self.setX509Extension(ExtensionType.KEY_USAGE,
False, "nonRepudiation, digitalSignature, keyEncipherment"),
])
def getSerialToInt(x509):
return '{0:x}'.format(int(x509.get_serial_number()))
Allows ensuring no rogue certificate could be emitted before legitimate owner
could take control of their instance: in such case, "first" certificate would
not appear as auto-signed.
def validateCertAndKey(cert_pem, key_pem):
ctx = SSL.Context(SSL.TLSv1_METHOD)
ctx.use_privatekey(key_pem)
ctx.use_certificate(cert_pem)
Returns True if certificate is auto-signed, False otherwise.
"""
try:
ctx.check_privatekey()
except SSL.Error:
return False
extension = crt.extensions.get_extension_for_class(
x509.CertificatePolicies,
)
except x509.ExtensionNotFound:
pass
else:
return True
for policy_information in extension.value:
if policy_information.policy_identifier == _CAUCASE_OID_AUTO_SIGNED:
return True
return False
def verifyCertificateChain(cert_pem, trusted_cert_list, crl=None):
# Create and fill a X509Sore with trusted certs
store = crypto.X509Store()
for trusted_cert in trusted_cert_list:
store.add_cert(trusted_cert)
if crl:
store.add_crl(crl)
store.set_flags(crypto.X509StoreFlags.CRL_CHECK)
def _getPEMTypeDict(path, result=None):
if result is None:
result = defaultdict(list)
for entry in pem.parse_file(path):
result[pem.Key if isinstance(entry, pem.Key) else type(entry)].append(
entry,
)
return result
def getCertList(crt_path):
"""
Return a list of certificates.
Raises if there is anything else than a certificate.
"""
type_dict = _getPEMTypeDict(crt_path)
crt_list = type_dict.pop(pem.Certificate)
if type_dict:
raise ValueError('%s contains more than just certificates' % (crt_path, ))
return [x.as_bytes() for x in crt_list]
store_ctx = crypto.X509StoreContext(store, cert_pem)
# Returns None if certificate can be validated
try:
result = store_ctx.verify_certificate()
except crypto.X509StoreContextError, e:
raise CertificateVerificationError('Certificate verification error: %s' % str(e))
except crypto.Error, e:
raise CertificateVerificationError('Certificate verification error: %s' % str(e))
def getCert(crt_path):
"""
Return a certificate from a file which may also contain a key.
Raises if there is more or less than one certificate.
"""
type_dict = _getPEMTypeDict(crt_path)
crt, = type_dict.get(pem.Certificate)
return crt.as_bytes()
if result is None:
return True
else:
return False
def hasOneCert(crt_path):
"""
Returns whether crt_path contains a certificate.
def checkCertificateValidity(ca_cert_list, cert_pem, key_pem=None):
False if there is no file at crt_path.
Raises if there is more than one certificate.
Ignores other types.
"""
if os.path.exists(crt_path):
crt_list = _getPEMTypeDict(crt_path).get(pem.Certificate, [])
if crt_list:
_, = crt_list
return True
return False
def getCertRequest(csr_path):
"""
Return a certificate request from a file.
Raises if there is more or less than one certificate request, or anything
else.
"""
type_dict = _getPEMTypeDict(csr_path)
csr, = type_dict.pop(pem.CertificateRequest)
if type_dict:
raise ValueError('%s contains more than just a csr' % (csr_path, ))
return csr.as_bytes()
if not verifyCertificateChain(cert_pem, ca_cert_list):
return False
if key_pem:
return validateCertAndKey(cert_pem, key_pem)
return True
def getKey(key_path):
"""
Return a key from a file.
Raises if there is more or less than one key, or anything else.
"""
type_dict = _getPEMTypeDict(key_path)
key, = type_dict.pop(pem.Key)
if type_dict:
raise ValueError('%s contains more than just a key' % (key_path, ))
return key.as_bytes()
def sign(data, key, digest="sha256"):
def getKeyPair(crt_path, key_path=None):
"""
Sign a data using digest and return signature.
Return a certificate and a key from a pair of file.
If crt_path contains both a cert and a key, key_path is ignored.
Raises if there is more than one certificate or more than one key.
Raises if key and cert do not match.
"""
pkey = crypto.load_privatekey(crypto.FILETYPE_PEM, key)
type_dict = _getPEMTypeDict(crt_path)
if pem.Key not in type_dict and key_path:
_getPEMTypeDict(key_path, type_dict)
else:
key_path = None
key, = type_dict[pem.Key]
crt, = type_dict[pem.Certificate]
key = key.as_bytes()
crt = crt.as_bytes()
validateCertAndKey(crt, key)
return crt, key, key_path
sign = crypto.sign(pkey, data, digest)
#data_base64 = base64.b64encode(sign)
def validateCertAndKey(cert_pem, key_pem):
"""
Verify certificate and key match.
return sign
Raises if it is not the case.
"""
if x509.load_pem_x509_certificate(
cert_pem,
_cryptography_backend,
).public_key().public_numbers() != load_privatekey(
key_pem,
).public_key().public_numbers():
raise ValueError('Mismatch between private key and certificate')
def _verifyCertificateChain(cert, trusted_cert_list, crl):
"""
Verifies whether certificate has been signed by any of the trusted
certificates, is not revoked and is whithin its validity period.
def verify(data, cert_string, signature, digest="sha256"):
Raises CertificateVerificationError if validation fails.
"""
Verify the signature for a data string.
# Note: this function (validating a certificate without an SSL connection)
# does not seem to have many equivalents at all in python. OpenSSL module
# seems to be a rare implementation of it, so we keep using this module.
# BUT it MUST NOT be used anywhere outside this function (hence the
# bad-style local import). Use "cryptography".
from OpenSSL import crypto
store = crypto.X509Store()
assert trusted_cert_list
for trusted_cert in trusted_cert_list:
store.add_cert(crypto.X509.from_cryptography(trusted_cert))
if crl is not None:
store.add_crl(crypto.CRL.from_cryptography(crl))
store.set_flags(crypto.X509StoreFlags.CRL_CHECK)
try:
crypto.X509StoreContext(
store,
crypto.X509.from_cryptography(cert),
).verify_certificate()
except (
crypto.X509StoreContextError,
crypto.Error,
), e:
raise CertificateVerificationError('Certificate verification error: %s' % str(e))
cert_string: is the certificate content as string
signature: is generate using 'signData' from the data to verify
data: content to verify
digest: by default is sha256, set the correct value
def wrap(payload, key, digest):
"""
Sign payload (which gets json-serialised) with key, using given digest.
"""
x509 = crypto.load_certificate(crypto.FILETYPE_PEM, cert_string)
return crypto.verify(x509, signature, data, digest.encode("ascii", 'ignore'))
payload = json.dumps(payload).encode('utf-8')
hash_class = getattr(hashes, digest.upper())
return {
'payload': payload,
'digest': digest,
'signature': key.sign(
payload + digest + ' ',
padding.PSS(
mgf=padding.MGF1(hash_class()),
salt_length=padding.PSS.MAX_LENGTH,
),
hash_class(),
).encode('base64'),
}
def wrap(payload, key, digest_list):
def nullWrap(payload):
"""
Sign payload (json-serialised) with key, using one of the given digests.
Wrap without signature. To only be used (and accepted) when user is
authenticated (and hence using a secure channel, HTTPS).
"""
# Choose a digest between the ones supported
# how to choose the default digest ?
digest = digest_list[0]
payload = json.dumps(payload)
return {
"payload": payload,
"digest": digest,
"signature": sign(payload + digest + ' ', key, digest).encode('base64'),
'payload': json.dumps(payload),
'digest': None,
}
def unwrap(wrapped, getCertificate, digest_list):
"""
Raise if signature does not match payload. Returns payload.
Check payload signature and return it.
Raises cryptography.exceptions.InvalidSignature if signature does not match
payload or if transmitted digest is not an acceptable one.
Note: does *not* verify received certificate itself (validity, issuer, ...).
"""
# Check whether given digest is allowed
if wrapped['digest'] not in digest_list:
raise BadSignature('Given digest is not supported')
digest = wrapped['digest'].encode('ascii')
if digest not in digest_list:
raise cryptography.exceptions.UnsupportedAlgorithm(
'%r is not in allowed digest list',
)
hash_class = getattr(hashes, digest.upper())
payload = json.loads(wrapped['payload'])
crt = getCertificate(payload)
try:
verify(wrapped['payload'] + wrapped['digest'] + ' ', crt, wrapped['signature'].decode('base64'), wrapped['digest'])
except crypto.Error, e:
raise BadSignature('Signature mismatch: %s' % str(e))
x509.load_pem_x509_certificate(
getCertificate(payload).encode('ascii'),
_cryptography_backend,
).public_key().verify(
wrapped['signature'].encode('ascii').decode('base64'),
wrapped['payload'].encode('utf-8') + digest + ' ',
padding.PSS(
mgf=padding.MGF1(hash_class()),
salt_length=padding.PSS.MAX_LENGTH,
),
hash_class(),
)
return payload
def nullUnwrap(wrapped):
"""
Un-wrapp unsigned content. To onl be used on content received from
an authenticated user (and hence over a secure channel, HTTPS).
"""
assert wrapped['digest'] is None
return json.loads(wrapped['payload'])
def load_ca_certificate(data):
"""
Load CA certificate from PEM-encoded data.
Raises CertificateVerificationError if loaded certificate is not self-signed
or is otherwise invalid.
"""
crt = x509.load_pem_x509_certificate(data, _cryptography_backend)
_verifyCertificateChain(crt, [crt], None)
return crt
def load_certificate(data, trusted_cert_list, crl):
"""
Load a certificate from PEM-encoded data.
Raises CertificateVerificationError if loaded certificate is not signed by
any of trusted certificates, is revoked or is otherwise invalid.
"""
crt = x509.load_pem_x509_certificate(data, _cryptography_backend)
_verifyCertificateChain(crt, trusted_cert_list, crl)
return crt
def dump_certificate(data):
"""
Serialise a certificate as PEM-encoded data.
"""
return data.public_bytes(serialization.Encoding.PEM)
def load_certificate_request(data):
"""
Load a certificate request from PEM-encoded data.
Raises cryptography.exceptions.InvalidSignature if certificate signature
does not match embedded public key.
"""
result = x509.load_pem_x509_csr(data, _cryptography_backend)
if not result.is_signature_valid:
raise cryptography.exceptions.InvalidSignature
return result
def dump_certificate_request(data):
"""
Serialise acertificate request as PEM-encoded data.
"""
return data.public_bytes(
encoding=serialization.Encoding.PEM,
)
def load_privatekey(data):
"""
Load a private key from PEM-encoded data.
"""
return serialization.load_pem_private_key(
data,
password=None,
backend=_cryptography_backend,
)
def dump_privatekey(data):
"""
Serialise a private key as PEM-encoded data.
"""
return data.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.TraditionalOpenSSL,
encryption_algorithm=serialization.NoEncryption(),
)
def generatePrivateKey(key_len):
"""
Generate a new private key of specified length.
"""
return rsa.generate_private_key(
public_exponent=65537,
key_size=key_len,
backend=_cryptography_backend,
)
def load_crl(data, trusted_cert_list):
"""
Load a certificate revocation list from PEM-encoded data.
If cryptography supports it, raises cryptography.exceptions.InvalidSignature
if the CRL signature does not match any trusted certificate.
"""
crl = x509.load_pem_x509_crl(data, _cryptography_backend)
for cert in trusted_cert_list:
# TODO: make mandatory when next cryptography version is released
if getattr(crl, 'is_signature_valid', lambda x: True)(cert.public_key()):
return crl
raise cryptography.exceptions.InvalidSignature
EPOCH = datetime.datetime(1970, 1, 1)
def datetime2timestamp(value):
"""
Convert given datetime into a unix timestamp.
"""
return (value - EPOCH).total_seconds()
class SleepInterrupt(KeyboardInterrupt):
"""
A sleep was interrupted by a KeyboardInterrupt
"""
pass
def interruptibleSleep(duration):
"""
Like sleep, but raises SleepInterrupt when interrupted by KeyboardInterrupt
"""
try:
time.sleep(duration)
except KeyboardInterrupt:
raise SleepInterrupt
def until(deadline):
"""
Call interruptibleSleep until deadline is reached.
"""
now = datetime.datetime.utcnow()
while now < deadline:
interruptibleSleep((deadline - now).total_seconds())
now = datetime.datetime.utcnow()
return now
# This file is part of caucase
# Copyright (C) 2017 Nexedi
# Alain Takoudjou <alain.takoudjou@nexedi.com>
# Vincent Pelletier <vincent@nexedi.com>
#
# caucase is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# caucase is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
import logging
import os, errno
import argparse
import traceback
import json
import flask
from flask import (session, request, redirect, url_for, render_template,
jsonify, abort, send_file, flash, g, Response)
from flask_user import UserManager, SQLAlchemyAdapter
from wtforms import StringField, SubmitField, validators
from flask_wtf import FlaskForm
from flask_mail import Mail
from flask_user import login_required, current_user
from flask_login import logout_user #, login_user, current_user, login_required
from caucase.ca import CertificateAuthority, DEFAULT_DIGEST_LIST, MIN_CA_RENEW_PERIOD
from caucase.exceptions import (NoStorage, NotFound, Found, BadSignature,
BadCertificateSigningRequest,
BadCertificate,
CertificateVerificationError,
ExpiredCertificate)
from functools import wraps
from caucase import utils, app, db
class DisabledStringField(StringField):
def __call__(self, *args, **kwargs):
kwargs.setdefault('disabled', True)
return super(ReadonlyStringField, self).__call__(*args, **kwargs)
# Define the User profile form
class UserProfileForm(FlaskForm):
username = StringField('Username')
first_name = StringField('First name', validators=[
validators.DataRequired('First name is required')])
last_name = StringField('Last name', validators=[
validators.DataRequired('Last name is required')])
email = StringField('Email', validators=[
validators.DataRequired('Email is required')])
submit = SubmitField('Save')
def parseArguments(argument_list=[]):
"""
Parse arguments for Certificate Authority instance.
"""
parser = argparse.ArgumentParser()
parser.add_argument('--ca-dir',
help='Certificate authority base directory')
parser.add_argument('-H', '--host',
default='127.0.0.1',
help='Host or IP of ca server. Default: %(default)s')
parser.add_argument('-P', '--port',
default='9086', type=int,
help='Port for ca server. Default: %(default)s')
parser.add_argument('-d', '--debug',
action="store_true", dest="debug", default=False,
help='Enable debug mode.')
parser.add_argument('-l', '--log-file',
help='Path for log output')
parser.add_argument('--crt-life-time',
default=365*24*60*60, type=int,
help='The time in seconds before a generated certificate will expire. Default: 365*24*60*60 seconds (1 year)')
parser.add_argument('-s', '--subject',
default='',
help='Formatted subject string to put into generated CA Certificate file. Ex: /C=XX/ST=State/L=City/OU=OUnit/O=Company/CN=CAAuth/emailAddress=xx@example.com')
parser.add_argument('--ca-life-period',
default=10, type=float,
help='Number of individual certificate validity periods during which the CA certificate is valid. Default: %(default)s')
parser.add_argument('--ca-renew-period',
default=MIN_CA_RENEW_PERIOD, type=float,
help='Number of individual certificate validity periods during which both the existing and the new CA Certificates are valid. Default: %(default)s')
parser.add_argument('--crl-life-period',
default=1/50., type=float,
help='Number of individual certificate validity periods during which the CRL is valid. Default: %(default)s')
parser.add_argument('-D', '--digest',
action='append', dest='digest_list', default=DEFAULT_DIGEST_LIST,
help='Allowed digest for all signature. Default: %(default)s')
parser.add_argument('--max-request-amount',
default=50,
help='Maximun pending certificate signature request amount. Default: %(default)s')
parser.add_argument('--crt-keep-time',
default=30*24*60*60, type=int,
help='The time in seconds before a generated certificate will be deleted on CA server. Set 0 to never delete. Default: 30*24*60*60 seconds (30 days)')
parser.add_argument('--external-url',
help="The HTTP URL at which this tool's \"/\" path is reachable by all certificates users in order to retrieve latest CRL.")
parser.add_argument('--auto-sign-csr-amount',
default=1, type=int,
help='Say how many csr must be signed automatically. Has no effect if there is more than the specified value of csr submitted.')
if argument_list:
return parser.parse_args(argument_list)
return parser.parse_args()
def getLogger(debug=False, log_file=None):
logger = logging.getLogger("CertificateAuthority")
logger.setLevel(logging.INFO)
if not log_file:
logger.addHandler(logging.StreamHandler())
else:
handler = logging.FileHandler(log_file)
handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
logger.addHandler(handler)
logger.info('Configured logging to file %r' % log_file)
if debug:
logger.setLevel(logging.DEBUG)
return logger
def getConfig(self, key):
if key in self.keys():
temp_dict = dict()
temp_dict.update(self)
return temp_dict[key]
else:
raise KeyError
def start():
"""
Start Web Flask application server
"""
options = parseArguments()
configure_flask(options)
app.logger.info("Certificate Authority server started on http://%s:%s" % (
options.host, options.port))
app.run(
host=options.host,
port=int(options.port)
)
def configure_flask(options):
"""
Configure certificate authority service
"""
if not options.ca_dir:
options.ca_dir = os.getcwd()
else:
options.ca_dir = os.path.abspath(options.ca_dir)
if not options.external_url:
options.external_url = 'http://[%s]:%s' % (options.host, options.port)
db_file = "sqlite:///%s"% os.path.join(options.ca_dir, 'ca.db')
# work in ca directory
os.chdir(options.ca_dir)
# init Flask app
app.config.update(
DEBUG=options.debug,
CSRF_ENABLED=True,
USER_AFTER_LOGIN_ENDPOINT='manage_csr',
USER_AFTER_LOGOUT_ENDPOINT='index',
USER_ENABLE_USERNAME=True,
USER_ENABLE_EMAIL=False,
USER_ENABLE_REGISTRATION=False,
USER_ENABLE_CHANGE_USERNAME=False,
SECRET_KEY = 'This is an UNSECURE Secret. Please CHANGE THIS for production environments.',
SQLALCHEMY_DATABASE_URI=db_file
)
flask.config.Config.__getattr__ = getConfig
mail = Mail(app)
# Setup Flask-User
# XXX - User table Will go away when switching to CA for Users
if not app.config['TESTING']:
from caucase.storage import User
db_adapter = SQLAlchemyAdapter(db, User) # Register the User model
user_manager = UserManager(db_adapter, app) # Initialize Flask-User
logger = getLogger(options.debug, options.log_file)
app.logger.addHandler(logger)
# Instanciate storage
from caucase.storage import Storage
storage = Storage(db,
max_csr_amount=options.max_request_amount,
crt_keep_time=options.crt_keep_time,
csr_keep_time=options.crt_keep_time)
ca = CertificateAuthority(
storage=storage,
ca_life_period=options.ca_life_period,
ca_renew_period=options.ca_renew_period,
crt_life_time=options.crt_life_time,
crl_renew_period=options.crl_life_period,
digest_list=options.digest_list,
crl_base_url='%s/crl' % options.external_url,
ca_subject=options.subject,
auto_sign_csr_amount=options.auto_sign_csr_amount
)
# XXX - Storage argument Will go away when switching to CA for Users
app.config.update(
storage=storage,
ca=ca,
log_file=options.log_file,
)
def check_authentication(username, password):
user = app.config.storage.findUser(username)
if user:
return app.user_manager.verify_password(password, user)
else:
return False
def authenticated_method(func):
""" This decorator ensures that the current user is logged in before calling the actual view.
Abort with 401 when the user is not logged in."""
@wraps(func)
def decorated_view(*args, **kwargs):
# User must be authenticated
auth = request.authorization
if not auth:
return abort(401)
elif not check_authentication(auth.username, auth.password):
return abort(401)
# Call the actual view
return func(*args, **kwargs)
return decorated_view
class FlaskException(Exception):
status_code = 400
code = 400
def __init__(self, message, status_code=None, payload=None):
Exception.__init__(self)
self.message = message
if status_code is not None:
self.status_code = status_code
self.payload = payload
def to_dict(self):
rv = dict(self.payload or ())
# rv['code'] = self.code
rv['message'] = self.message
return rv
@app.errorhandler(FlaskException)
def handle_invalid_usage(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
@app.errorhandler(401)
def error401(error):
if error.description is None:
message = {
'code': 401,
'name': 'Unauthorized',
'message': "Authenticate."
}
else:
message = error.description
response = jsonify(message)
response.status_code = 401
response.headers['WWW-Authenticate'] = 'Basic realm="Login Required"'
return response
@app.errorhandler(403)
def error403(error):
if error.description is None:
message = {
'code': 404,
'name': 'Forbidden',
'message': 'Forbidden. Your are not allowed to access %s' % request.url,
}
else:
message = error.description
response = jsonify(message)
response.status_code = 404
return response
@app.errorhandler(404)
def error404(error):
if error.description is None:
message = {
'code': 404,
'name': 'NotFound',
'message': 'Resource not found: ' + request.url,
}
else:
message = error.description
response = jsonify(message)
response.status_code = 404
return response
@app.errorhandler(400)
def error400(error):
if error.description is None:
message = {
'code': 400,
'name': 'BadRequest',
'message': 'The request could not be understood by the server, you probably provided wrong parameters.'
}
else:
message = error.description
response = jsonify(message)
response.status_code = 400
return response
def send_file_content(content, filename, mimetype='text/plain'):
return Response(content,
mimetype=mimetype,
headers={"Content-Disposition":
"attachment;filename=%s" % filename})
@app.before_request
def before_request():
# XXX - This function Will be modified or removed when switching to CA for Users
is_admin_path = request.path.startswith('/admin') or request.path.startswith('/user')
if not is_admin_path and not request.path.startswith('/certificates'):
return
if is_admin_path:
csr_count = app.config.storage.countPendingCertificateSiningRequest()
if csr_count < 10:
csr_count = '0%s' % csr_count
session['count_csr'] = csr_count
if request.path == '/admin/configure' or request.path == '/admin/setpassword':
# check if password file exists, if yes go to index
if app.config.storage.findUser('admin'):
return redirect(url_for('admin'))
return
# XXX - using hard username
if not app.config.storage.findUser('admin'):
return redirect(url_for('configure'))
g.user = current_user
# Routes for certificate Authority
@app.route('/crl', methods=['GET'])
def get_crl():
"""
Get the lastest CRL (certificate revocation list)
"""
crl_content = app.config.ca.getCertificateRevocationList()
return send_file_content(crl_content, 'ca.crl.pem')
@app.route('/csr/<string:csr_id>', methods=['GET'])
def get_csr(csr_id):
"""
Get a CSR string in PEM format from identified by `csr_id`.
"""
try:
csr_content = app.config.ca.getPendingCertificateRequest(csr_id)
except NotFound, e:
raise FlaskException(str(e),
status_code=404, payload={"name": "FileNotFound", "code": 1})
return send_file_content(csr_content, csr_id)
@app.route('/csr', methods=['PUT'])
def request_cert():
"""
Store certificate signature request (csr) in PEM format
"""
csr_content = request.form.get('csr', '').encode('utf-8')
if not csr_content:
raise FlaskException("'csr' parameter is mandatory",
payload={"name": "MissingParameter", "code": 2})
try:
csr_id = app.config.ca.createCertificateSigningRequest(csr_content)
except BadCertificateSigningRequest, e:
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
except NoStorage, e:
raise FlaskException(str(e),
payload={"name": "NoStorage", "code": 4})
response = Response("", status=201)
response.headers['Location'] = url_for('get_csr', _external=True, csr_id=csr_id)
return response
@app.route('/csr/<string:csr_id>', methods=['DELETE'])
@authenticated_method
def remove_csr(csr_id):
"""
Delete a Certificate signature request. Authentication required
"""
try:
app.config.ca.deletePendingCertificateRequest(csr_id)
except NotFound, e:
raise FlaskException("%s" % str(e),
status_code=404, payload={"name": "FileNotFound", "code": 1})
response = Response("", status=200)
return response
@app.route('/crt/<string:cert_id>', methods=['GET'])
def get_crt(cert_id):
"""
Get a certificate by the id `cert_id`
"""
try:
cert_content = app.config.ca.getCertificate(cert_id)
except NotFound, e:
raise FlaskException("%s" % str(e),
status_code=404, payload={"name": "FileNotFound", "code": 1})
return send_file_content(cert_content, cert_id)
@app.route('/crt/serial/<string:serial>', methods=['GET'])
def crt_fromserial(serial):
"""
Get a certificate by the serial
"""
try:
cert_content = app.config.ca.getCertificateFromSerial(serial)
except NotFound, e:
raise FlaskException("%s" % str(e),
status_code=404, payload={"name": "FileNotFound", "code": 1})
return send_file_content(cert_content, '%s.crt.pem' % serial)
@app.route('/crt/ca.crt.pem', methods=['GET'])
def get_cacert():
"""
Get CA Certificate in PEM format string.
"""
ca_cert = app.config.ca.getCACertificate()
return send_file_content(ca_cert, 'ca.crt.pem')
@app.route('/crt/ca.crt.json', methods=['GET'])
def get_cacert_json():
"""
Return CA certificate chain list, if the CA certificate is being renewed
the list will contain the next certificate and the old certificate which
will expire soon.
"""
ca_chain_list = app.config.ca.getValidCACertificateChain()
return jsonify(ca_chain_list)
def signcert(csr_key, subject_dict=None, redirect_to=''):
try:
cert_id = app.config.ca.createCertificate(csr_key, subject_dict=subject_dict)
except NotFound, e:
raise FlaskException("%s" % str(e),
status_code=404, payload={"name": "FileNotFound", "code": 1})
except Found, e:
# Certificate is found
raise FlaskException("%s" % str(e),
payload={"name": "FileFound", "code": 5})
# XXX - to remove (flask UI)
flash('Certificate is signed!', 'success')
if redirect_to:
return redirect(url_for(redirect_to))
response = Response("", status=201)
response.headers['Location'] = url_for('get_crt', _external=True, cert_id=cert_id)
return response
@app.route('/crt', methods=['PUT'])
@authenticated_method
def sign_cert():
"""
Sign a certificate, require authentication
"""
key = request.form.get('csr_id', '').encode('utf-8')
if not key:
raise FlaskException("'csr_id' parameter is a mandatory parameter",
payload={"name": "MissingParameter", "code": 2})
try:
subject = request.form.get('subject', '').encode('utf-8')
subject_dict = None
if subject:
subject_dict = json.loads(subject)
return signcert(key, subject_dict=subject_dict)
except ValueError, e:
traceback.print_exc()
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
except AttributeError, e:
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
@app.route('/crt/renew', methods=['PUT'])
def renew_cert():
"""
this method is used to renew expired certificate.
"""
payload = request.form.get('payload', '')
if not payload:
# Bad parameters
raise FlaskException("'payload' parameter is mandatory",
payload={"name": "MissingParameter", "code": 2})
try:
wrapped = json.loads(payload)
except ValueError, e:
raise FlaskException("payload parameter is not a valid Json string: %s" % str(e),
payload={"name": "FileFormat", "code": 3})
try:
cert_id = app.config.ca.renew(wrapped)
except ValueError, e:
traceback.print_exc()
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
except KeyError, e:
traceback.print_exc()
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
except BadSignature, e:
raise FlaskException(str(e),
payload={"name": "SignatureMismatch", "code": 6})
except BadCertificateSigningRequest, e:
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
except BadCertificate, e:
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
except CertificateVerificationError, e:
raise FlaskException(str(e),
payload={"name": "SignatureMismatch", "code": 6})
except NoStorage, e:
raise FlaskException(str(e),
payload={"name": "NoStorage", "code": 4})
except NotFound, e:
raise FlaskException(str(e),
status_code=404, payload={"name": "FileNotFound", "code": 1})
except Found, e:
# Certificate is found
raise FlaskException(str(e),
payload={"name": "FileFound", "code": 5})
response = Response("", status=201)
response.headers['Location'] = url_for('get_crt', _external=True, cert_id=cert_id)
return response
@app.route('/crt/revoke', methods=['PUT'])
def request_revoke_crt():
"""
Revoke method existing and valid certificate
"""
payload = request.form.get('payload', '')
if not payload:
# Bad parameters
raise FlaskException("'payload' parameter is mandatory",
payload={"name": "MissingParameter", "code": 2})
try:
wrapped = json.loads(payload)
except ValueError, e:
raise FlaskException("payload parameter is not a valid Json string: %s" % str(e),
payload={"name": "FileFormat", "code": 3})
try:
app.config.ca.revokeCertificate(wrapped)
except ValueError, e:
traceback.print_exc()
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
except KeyError, e:
traceback.print_exc()
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
except BadSignature, e:
raise FlaskException(str(e),
payload={"name": "SignatureMismatch", "code": 6})
except CertificateVerificationError, e:
raise FlaskException(str(e),
payload={"name": "SignatureMismatch", "code": 6})
except BadCertificate, e:
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
except ExpiredCertificate, e:
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
except NotFound, e:
raise FlaskException(str(e),
status_code=404, payload={"name": "FileNotFound", "code": 1})
response = Response("", status=201, )
return response
@app.route('/crt/revoke/id', methods=['PUT'])
@authenticated_method
def revoke_crt():
"""
Directly revoke a certificate from his serial
"""
try:
crt_id = request.form.get('crt_id', '')
if not crt_id:
raise FlaskException("'crt_id' parameter is mandatory",
payload={"name": "MissingParameter", "code": 2})
app.config.ca.revokeCertificateFromID(crt_id)
except ValueError, e:
traceback.print_exc()
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
except ExpiredCertificate, e:
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
except NotFound, e:
raise FlaskException(str(e),
status_code=404, payload={"name": "FileNotFound", "code": 1})
response = Response("", status=201)
return response
#Manage routes (Authentication required) - Flask APP
# XXX - this routes will be updated or removed after implement ca_user
@app.route('/')
def home():
return redirect(url_for('index'))
@app.route('/certificates')
def index():
# page to list certificates, also connection link
data_list = app.config.ca.getSignedCertificateList()
return render_template("index.html", data_list=data_list)
@app.route('/admin/logout')
def logout():
logout_user()
return redirect(url_for('index'))
@app.route('/admin/')
@login_required
def admin():
return index()
@app.route('/admin/csr_requests', methods=['GET'])
@login_required
def manage_csr():
data_list = app.config.ca.getPendingCertificateRequestList()
return render_template('manage_page.html', data_list=data_list)
@app.route('/admin/configure', methods=['GET'])
def configure():
return render_template("configure.html")
@app.route('/admin/setpassword', methods=['POST'])
def setpassword():
username = 'admin'
password = request.form.get('password', '').encode('utf-8')
if not password:
raise FlaskException("'password' parameter is mandatory",
payload={"name": "MissingParameter", "code": 2})
app.config.storage.findOrCreateUser(
"Admin",
"admin",
"admin@example.com",
username,
app.user_manager.hash_password(password))
logout_user()
return redirect(url_for('manage_csr'))
@app.route('/admin/signcert', methods=['GET'])
@login_required
def do_signcert_web():
csr_id = request.args.get('csr_id', '').encode('utf-8')
if not csr_id:
raise FlaskException("'csr_id' parameter is a mandatory parameter",
payload={"name": "MissingParameter", "code": 2})
try:
return signcert(csr_id, subject_dict=None, redirect_to='manage_csr')
except ValueError, e:
raise FlaskException(str(e),
payload={"name": "FileFormat", "code": 3})
@app.route('/admin/deletecsr', methods=['GET'])
@login_required
def deletecsr():
"""
Delete certificate signature request file
"""
csr_id = request.args.get('csr_id', '').encode('utf-8')
if not csr_id:
raise FlaskException("'csr_id' parameter is a mandatory parameter",
payload={"name": "MissingParameter", "code": 2})
try:
app.config.ca.deletePendingCertificateRequest(csr_id)
except NotFound, e:
raise FlaskException("%s" % str(e),
status_code=404, payload={"name": "FileNotFound", "code": 1})
return redirect(url_for('manage_csr'))
@app.route('/admin/profile', methods=['GET', 'POST'])
@login_required
def user_profile():
form = UserProfileForm(request.form, obj=current_user)
if request.method == 'POST' and form.validate():
# Copy form fields to user_profile fields
del form.username # revove username from recieved form
form.populate_obj(current_user)
db.session.commit()
# Redirect to home page
return redirect(url_for('index'))
return render_template('user_profile.html',
form=form)
......@@ -15,42 +15,356 @@
#
# You should have received a copy of the GNU General Public License
# along with caucase. If not, see <http://www.gnu.org/licenses/>.
"""
Caucase - Certificate Authority for Users, Certificate Authority for SErvices
"""
from __future__ import absolute_import
import httplib
import json
import traceback
import sys
from . import utils
from . import exceptions
__all__ = ('Application', )
import os
from caucase import app
from caucase.web import parseArguments, configure_flask
from werkzeug.contrib.fixers import ProxyFix
def _getStatus(code):
return '%i %s' % (code, httplib.responses[code])
def readConfigFromFile(config_file):
config_list = []
with open(config_file) as f:
for line in f.readlines():
if not line or line.startswith('#'):
continue
line_list = line.strip().split(' ')
if len(line_list) == 1:
config_list.append('--%s' % line_list[0].strip())
elif len(line_list) > 1:
config_list.append('--%s' % line_list[0].strip())
config_list.append(' '.join(line_list[1:]))
class ApplicationError(Exception):
"""
WSGI HTTP error base class.
"""
status = _getStatus(httplib.INTERNAL_SERVER_ERROR)
response_headers = ()
class BadRequest(ApplicationError):
"""
HTTP bad request error
"""
status = _getStatus(httplib.BAD_REQUEST)
return parseArguments(config_list)
class NotFound(ApplicationError):
"""
HTTP not found error
"""
status = _getStatus(httplib.NOT_FOUND)
def start_wsgi():
class BadMethod(ApplicationError):
"""
HTTP bad method error
"""
Start entry for wsgi, do not run app.run, read config from file
status = _getStatus(httplib.METHOD_NOT_ALLOWED)
class Conflict(ApplicationError):
"""
HTTP conflict
"""
status = _getStatus(httplib.CONFLICT)
class TooLarge(ApplicationError):
"""
HTTP too large error
"""
status = _getStatus(httplib.REQUEST_ENTITY_TOO_LARGE)
class InsufficientStorage(ApplicationError):
"""
if os.environ.has_key('CA_CONFIGURATION_FILE'):
config_file = os.environ['CA_CONFIGURATION_FILE']
else:
config_file = 'ca.conf'
No storage slot available (not necessarily out of disk space)
"""
# httplib lacks the textual description for 507, although it has the constant...
status = '%i Insufficient Storage' % (httplib.INSUFFICIENT_STORAGE, )
STATUS_OK = _getStatus(httplib.OK)
STATUS_CREATED = _getStatus(httplib.CREATED)
STATUS_NO_CONTENT = _getStatus(httplib.NO_CONTENT)
MAX_BODY_LENGTH = 10 * 1024 * 1024 # 10 MB
class Application(object):
"""
WSGI application class
Thread- and process-safe (locks handled by sqlite3).
"""
def __init__(self, cau, cas):
"""
cau (caucase.ca.CertificateAuthority)
CA for users.
Will be hosted under /cau
cas (caucase.ca.CertificateAuthority)
CA for services.
Will be hosted under /cas
"""
self._cau = cau
self._cas = cas
def __call__(self, environ, start_response):
"""
WSGI entry point
"""
try: # Convert ApplicationError subclasses in error responses
try: # Convert non-wsgi exceptions into WSGI exceptions
path_item_list = [x for x in environ['PATH_INFO'].split('/') if x]
try:
context_id, method_id = path_item_list[:2]
except ValueError:
raise NotFound
if context_id == 'cau':
context = self._cau
elif context_id == 'cas':
context = self._cas
else:
raise NotFound
if method_id.startswith('_'):
raise NotFound
try:
method = getattr(self, method_id)
except AttributeError:
raise NotFound
status, header_list, result = method(context, environ, path_item_list[2:])
except ApplicationError:
raise
except exceptions.NotFound:
raise NotFound
except exceptions.Found:
raise Conflict
except exceptions.NoStorage:
raise InsufficientStorage
except exceptions.CertificateAuthorityException, e:
raise BadRequest(str(e))
except Exception:
print >>sys.stderr, 'Unhandled exception',
traceback.print_exc(file=sys.stderr)
raise ApplicationError
except ApplicationError, e:
start_response(
e.status,
list(e.response_headers),
)
result = [str(x) for x in e.args]
else:
start_response(
status,
header_list,
)
return result
@staticmethod
def _read(environ):
"""
Read the entire request body.
Raises BadRequest if request Content-Length cannot be parsed.
Raises TooLarge if Content-Length if over MAX_BODY_LENGTH.
If Content-Length is not set, reads at most MAX_BODY_LENGTH bytes.
"""
try:
length = int(environ.get('CONTENT_LENGTH', MAX_BODY_LENGTH))
except ValueError:
raise BadRequest('Invalid Content-Length')
if length > MAX_BODY_LENGTH:
raise TooLarge('Content-Length limit exceeded')
return environ['wsgi.input'].read(length)
def _authenticate(self, environ):
"""
Verify user authentication.
Raises NotFound if authentication does not pass checks.
"""
# Note on NotFound usage here: HTTP specs do not describe how to request
# client to provide transport-level authentication mechanism (x509 cert)
# so 401 is not applicable. 403 is not applicable either as spec requests
# client to not retry the request. 404 is recommended when server does not
# wish to disclose the reason why it rejected the access, so let's use
# this.
try:
ca_list = self._cau.getCACertificateList()
utils.load_certificate(
environ.get('SSL_CLIENT_CERT', b''),
trusted_cert_list=ca_list,
crl=utils.load_crl(
self._cau.getCertificateRevocationList(),
ca_list,
),
)
except (exceptions.CertificateVerificationError, ValueError):
raise NotFound
def _readJSON(self, environ):
"""
Read request body and convert to json object.
Raises BadRequest if request Content-Type is not 'application/json', or if
json decoding fails.
"""
if environ.get('CONTENT_TYPE') != 'application/json':
raise BadRequest('Bad Content-Type')
data = self._read(environ)
try:
return json.loads(data)
except ValueError:
raise BadRequest('Invalid json')
configure_flask(readConfigFromFile(config_file))
@staticmethod
def crl(context, environ, subpath):
"""
Handle /{context}/crl urls.
"""
if subpath:
raise NotFound
if environ['REQUEST_METHOD'] != 'GET':
raise BadMethod
data = context.getCertificateRevocationList()
return (
STATUS_OK,
[
('Content-Type', 'application/pkix-crl'),
('Content-Length', str(len(data))),
],
[data],
)
app.wsgi_app = ProxyFix(app.wsgi_app)
app.logger.info("Certificate Authority server ready...")
def csr(self, context, environ, subpath):
"""
Handle /{context}/csr urls.
"""
http_method = environ['REQUEST_METHOD']
if http_method == 'GET':
if subpath:
try:
csr_id, = subpath
except ValueError:
raise NotFound
try:
csr_id = int(csr_id)
except ValueError:
raise BadRequest('Invalid integer')
data = context.getCertificateSigningRequest(csr_id)
content_type = 'application/pkcs10'
else:
self._authenticate(environ)
data = json.dumps(context.getCertificateRequestList())
content_type = 'application/json'
return (
STATUS_OK,
[
('Content-Type', content_type),
('Content-Length', str(len(data))),
],
[data],
)
elif http_method == 'PUT':
if subpath:
raise NotFound
csr_id = context.appendCertificateSigningRequest(self._read(environ))
return (
STATUS_CREATED,
[
('Location', str(csr_id)),
],
[],
)
elif http_method == 'DELETE':
try:
csr_id, = subpath
except ValueError:
raise NotFound
self._authenticate(environ)
try:
context.deletePendingCertificateSigningRequest(csr_id)
except exceptions.NotFound:
raise NotFound
return (STATUS_NO_CONTENT, [], [])
else:
raise BadMethod
if __name__ == 'caucase.wsgi':
start_wsgi()
def crt(self, context, environ, subpath):
"""
Handle /{context}/crt urls.
"""
http_method = environ['REQUEST_METHOD']
try:
crt_id, = subpath
except ValueError:
raise NotFound
if http_method == 'GET':
if crt_id == 'ca.crt.pem':
data = context.getCACertificate()
content_type = 'application/pkix-cert'
elif crt_id == 'ca.crt.json':
data = json.dumps(context.getValidCACertificateChain())
content_type = 'application/json'
else:
try:
crt_id = int(crt_id)
except ValueError:
raise BadRequest('Invalid integer')
data = context.getCertificate(crt_id)
content_type = 'application/pkix-cert'
return (
STATUS_OK,
[
('Content-Type', content_type),
('Content-Length', str(len(data))),
],
[data],
)
elif http_method == 'PUT':
if crt_id == 'renew':
payload = utils.unwrap(
self._readJSON(environ),
lambda x: x['crt_pem'],
context.digest_list,
)
data = context.renew(
crt_pem=payload['crt_pem'].encode('ascii'),
csr_pem=payload['renew_csr_pem'].encode('ascii'),
)
return (
STATUS_OK,
[
('Content-Type', 'application/pkix-cert'),
('Content-Length', str(len(data))),
],
[data],
)
elif crt_id == 'revoke':
data = self._readJSON(environ)
if data['digest'] is None:
self._authenticate(environ)
payload = utils.nullUnwrap(data)
if 'revoke_crt_pem' not in payload:
context.revokeSerial(payload['revoke_serial'])
return (STATUS_NO_CONTENT, [], [])
else:
payload = utils.unwrap(
data,
lambda x: x['revoke_crt_pem'],
context.digest_list,
)
context.revoke(
crt_pem=payload['revoke_crt_pem'].encode('ascii'),
)
return (STATUS_NO_CONTENT, [], [])
else:
try:
crt_id = int(crt_id)
except ValueError:
raise BadRequest('Invalid integer')
body = self._read(environ)
if not body:
template_csr = None
elif environ.get('CONTENT_TYPE') == 'application/pkcs10':
template_csr = utils.load_certificate_request(body)
else:
raise BadRequest('Bad Content-Type')
self._authenticate(environ)
context.createCertificate(
csr_id=crt_id,
template_csr=template_csr,
)
return (STATUS_NO_CONTENT, [], [])
else:
raise BadMethod
......@@ -9,10 +9,10 @@ autonumber
== Signing Request Submission ==
User -> Authority : POST the CRL
alt Sining request passes all checks
Authority --> User : Signing request identifier
else
User -> Authority : PUT /csr with the CSR as body
alt CSR passes format check
Authority --> User : Request identifier
else CSR format invalid
Authority --> User : Error
end
Note over User : See "Certificate Retrieval"
......@@ -20,18 +20,18 @@ Note over User : See "Certificate Retrieval"
== Certificate Production ==
Note over Trusted : See "Signing Request Submission"
Trusted -> Authority : GET (optional: with result range expression)
Trusted -> Authority : GET /csr
Authority --> Trusted : List of pending signing requests with their identifiers
Trusted -> Authority : GET with request identifier
Authority --> Trusted : Signing request content
alt Trusted agrees to prvoduce a signed certificate from the signing request
Trusted -> Authority : POST with the signing request identifier
alt Sining request was still pending
Trusted -> Authority : GET /csr/<request identifier>
Authority --> Trusted : CSR
alt Trusted agrees to produce a signed certificate from the signing request
Trusted -> Authority : PUT /crt/<request identifier>
alt CSR was still pending
Authority --> Trusted : Success
else
else CSR not pending (deleted or already signed)
Authority --> Trusted : Not found
end
else
else Trusted refuses to sign the request
Trusted -> Authority : DELETE with the signing request identifier
Authority --> Trusted : Ok
end
......@@ -39,16 +39,16 @@ end
== Certificate Retrieval ==
loop Until certificate obtained or request rejected
User -> Authority : GET with signing request identifier
alt Signing request was signed
User -> Authority : GET /crt/<request identifier>
alt CRT exists
Authority --> User : Certificate content
else
else CRT does not exist
Authority --> User : Not found
opt User wants to check request is still pending
User -> Authority : GET with signing request identifier
alt Sining request is still pending
opt User checks if the CSR was rejected
User -> Authority : GET /csr/<request identifier>
alt CSR still pending
Authority --> User : Signing request content
else
else CSR rejected
Authority --> User : Not found
end
end
......@@ -57,25 +57,43 @@ end
== Certificate Renewal ==
User -> Authority : POST with the still-valid CRT and a CRL
alt Renewal parameters consistent
Authority --> User : signing request identifier
else
User -> Authority : PUT /crt/renew with the still-valid CRT and a CRL with the new public key
alt CRT is still valid (validity period, not revoked)
Authority --> User : New certificate content
else CRT invalid
Authority --> User : Error
end
Note over User : See "Certificate Retrieval"
== Certificate Revocation ==
User -> Authority : POST with the CRT
alt Revocation parameters consistent
Authority --> User : Ok
else
User -> Authority : PUT /crt/revoke with the CRT, order signed with its private key
alt CRT is valid and parameters consistent
Authority --> User : CRT revoked
else CRT is invalid or parameters inconsistent
Authority --> User : Error
end
== Certificate Revocation without access to private key ==
Trusted -> Authority : PUT /crt/revoke with the CRT
alt CRT is valid
Authority --> Trusted : CRT revoked
else CRT is invalid
Authority --> Trusted : Error
end
== Certificate Revocation without access to private key or the certificate ==
Note over Trusted: This procedure is discouraged as revoked certificate will linger for much longer\nthan strictly needed in the CRL, but useful when only the bare minimum\nis know about the certificate which revocation is desired.
Trusted -> Authority : PUT /crt/revoke with the serial to revoke
alt Serial is not revoked yet
Authority --> Trusted : CRT revoked
else Serials is already revoked
Authority --> Trusted : Error
end
== Certificate Validity Check ==
Service -> Authority : GET (optional: with OCSP parameter)
Authority --> Service : Certificate revocation list
Service -> Authority : GET /crl
Authority --> Service : CRL content
@enduml
swagger: '2.0'
info:
title: Certificate Authority
description: Automated x509 certificate authority for use with non-http services
version: 0.0.1
title: caucase
description: Certificate Authority for Users, Certificate Authority for SErvices
version: 0.2.0
contact:
name: Vincent Pelletier (Nexedi)
url: 'http://www.nexedi.com'
......@@ -13,33 +13,29 @@ schemes:
- https
consumes:
- application/json
- application/pkcs10
produces:
- application/xml
- application/json
- application/pkix-cert
- application/pkix-crl
- application/pkcs10
- application/x-x509-ca-cert
tags:
- name: todo
description: Known as not fully specified yet
- name: auth
description: https client authentication required
paths:
/csr:
get:
tags:
- todo
summary: List pending certificate signing requests - XXX PROPFIND, not GET !
summary: List pending certificate signing requests
operationId: getPendingCertificateRequestList
schemes:
- https
parameters:
- $ref: '#/parameters/x-auth'
tags:
- auth
produces:
- application/json
responses:
'401':
$ref: '#/responses/401'
'403':
$ref: '#/responses/403'
'500':
$ref: '#/responses/500'
'200':
description: OK - CSR list returned
'404':
$ref: '#/responses/404'
put:
summary: Request a new certificate signature
operationId: createCertificateSigningRequest
......@@ -54,32 +50,21 @@ paths:
Location:
description: URL of created resource
type: string
'400':
$ref: '#/responses/400'
'500':
$ref: '#/responses/500'
'507':
$ref: '#/responses/507'
/csr/{crt-id}:
delete:
summary: Reject a pending certificate signing request
operationId: deletePendingCertificateRequest
schemes:
- https
tags:
- auth
parameters:
- $ref: '#/parameters/x-auth'
- $ref: '#/parameters/crt-id'
responses:
'204':
description: No Content - CSR was rejected
'401':
$ref: '#/responses/401'
'403':
$ref: '#/responses/403'
description: No Content - CSR was successfuly rejected
'404':
$ref: '#/responses/404'
'500':
$ref: '#/responses/500'
get:
summary: Retrieve a pending certificate signing request
operationId: getCertificateSigningRequest
......@@ -90,37 +75,21 @@ paths:
responses:
'200':
description: OK - CSR retrieved
'400':
$ref: '#/responses/400'
'404':
$ref: '#/responses/404'
'500':
$ref: '#/responses/500'
/crt:
/crt/{crt-id}:
put:
summary: Accept pending certificate signing request
operationId: createCertificate
schemes:
- https
consumes:
- application/pkcs10
parameters:
- $ref: '#/parameters/x-auth'
- $ref: '#/parameters/csr'
tags:
- auth
responses:
'201':
description: Created - Certificate was signed
headers:
Location:
description: URL of created resource
type: string
'401':
$ref: '#/responses/401'
'204':
description: No Content - CSR was successfuly signed
'404':
$ref: '#/responses/404'
'403':
$ref: '#/responses/403'
'500':
$ref: '#/responses/500'
/crt/{crt-id}:
get:
summary: Retrieve a signed certificate
operationId: getCertificate
......@@ -133,81 +102,62 @@ paths:
description: OK - CRT retrieved
'404':
$ref: '#/responses/404'
'500':
$ref: '#/responses/500'
/crt/ca.crt.pem:
get:
summary: Retrieve current CA certificate
operationId: getCACertificate
produces:
- application/x-x509-ca-cert
responses:
'200':
description: OK - CA CRT retrieved
/crt/ca.crt.json:
get:
summary: Retrieve current CA certificate trust chain
description: Response schema is described separately.
operationId: getCACertificateChain
produces:
- application/json
responses:
'200':
description: OK - CA CRT chain retrieved
/crt/revoke:
put:
summary: Revoke a certificate
description: >
Response status 400 may mean operation could not be authenticated (signature hash mechanism not supported by server, signature did not match...). Signed operation payload schema is described separately.
description: Signed operation payload schema is described separately.
operationId: revokeCertificate
consumes:
- application/json
parameters:
- $ref: '#/parameters/signed-operation'
responses:
'201':
description: Created - Signing request was revoked
headers:
Location:
description: URL of created resource
type: string
'400':
$ref: '#/responses/400'
'500':
$ref: '#/responses/500'
'204':
description: No Content - certificate revoked
/crt/renew:
put:
summary: Renew a certificate
description: >
Response status 400 may mean operation could not be authenticated (signature hash mechanism not supported by server, signature did not match...), in addition to createCertificateSigningRequest status 400 reasons. Signed operation payload schema is described separately.
description: Signed operation payload schema is described separately.
operationId: renewCertificate
consumes:
- application/json
parameters:
- $ref: '#/parameters/signed-operation'
responses:
'201':
description: Created - Renewwal request was accepted
headers:
Location:
description: URL of created resource
type: string
'400':
$ref: '#/responses/400'
'500':
$ref: '#/responses/500'
'200':
description: OK - Renewed certificate retrieved
/crl:
get:
summary: Retrieve latest certificate revocation list
operationId: getCertificateRevocationList
produces:
- application/x-x509-ca-cert
- application/pkix-crl
responses:
'200':
description: OK - CRL retrieved
'500':
$ref: '#/responses/500'
definitions:
csr:
type: string
description: application/pkcs10 data
Error:
type: object
required:
- code
- name
- message
properties:
code:
type: integer
description: application-specific error code
name:
type: string
description: the explicit error name
message:
type: string
description: describes the error
signed-operation:
type: object
required:
......@@ -231,12 +181,6 @@ parameters:
description: Opaque certificate signing request identifier
required: true
type: string
x-auth:
name: Authorization
in: header
description: Credentials for this request
type: string
required: true
csr:
name: csr
in: body
......@@ -253,25 +197,7 @@ parameters:
responses:
'400':
description: Bad Request - you probably provided wrong parameters
schema:
$ref: '#/definitions/Error'
'401':
description: Unauthorized - No Authorization header provided
headers:
Authenticate:
type: string
description: Requests that client provides credentials
schema:
$ref: '#/definitions/Error'
'403':
description: Forbidden - Authorization headed provided, but does not grant access
schema:
$ref: '#/definitions/Error'
'404':
description: Not Found - Requested resource does not exist
schema:
$ref: '#/definitions/Error'
'500':
description: Internal Server Error
description: Not Found - Requested resource does not exist, or you did not provide required transport-level credentials (x509 cert over https)
'507':
description: Insufficient Storage
......@@ -20,60 +20,49 @@ from setuptools import setup, find_packages
import glob
import os
version = '0.1.4'
name = 'caucase'
long_description = open("README.rst").read() + "\n"
for f in sorted(glob.glob(os.path.join('caucase', 'README.*.rst'))):
long_description += '\n' + open(f).read() + '\n'
# long_description += open("CHANGES.txt").read() + "\n"
# Provide a way to install additional requirements
additional_install_requires = []
try:
import argparse
except ImportError:
additional_install_requires.append('argparse')
setup(name=name,
version=version,
description="Certificate Authority.",
long_description=long_description,
classifiers=[
"Programming Language :: Python",
],
keywords='certificate authority',
url='https://lab.nexedi.com/nexedi/caucase',
license='GPLv3',
namespace_packages=['caucase'],
packages=find_packages(),
include_package_data=True,
install_requires=[
'Flask', # needed by servers
'flask_user',
'Flask-AlchemyDumps',
'setuptools', # namespaces
'pyOpenSSL', # manage ssl certificates
'pyasn1', # ASN.1 types and codecs for certificates
'pyasn1-modules',
'requests', # http requests
'pem', # Parse PEM files
] + additional_install_requires,
extras_require = {
},
tests_require = [
'Flask-Testing',
],
zip_safe=False, # proxy depends on Flask, which has issues with
# accessing templates
entry_points={
'console_scripts': [
'caucase = caucase.web:start',
'caucase-cli = caucase.cli:main',
'caucase-cliweb = caucase.cli_flask:main',
]
},
test_suite='caucase.test',
)
setup(
name='caucase',
version='0.9.0',
description="Certificate Authority.",
long_description=long_description,
classifiers=[
'Environment :: Console',
'Environment :: Web Environment',
'Intended Audience :: System Administrators',
'Intended Audience :: Information Technology',
'License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)',
'Topic :: Security :: Cryptography',
'Topic :: System :: Systems Administration :: Authentication/Directory',
'Topic :: Internet :: WWW/HTTP :: WSGI :: Application',
],
keywords='certificate authority',
url='https://lab.nexedi.com/nexedi/caucase',
license='GPLv3+',
packages=find_packages(),
install_requires=[
'cryptography', # everything x509 except...
'pyOpenSSL', # ...certificate chain validation
'pem', # Parse PEM files
],
tests_require=[
'coverage',
'pylint',
],
zip_safe=True,
entry_points={
'console_scripts': [
'caucase = caucase.cli:main',
'caucase-probe = caucase.cli:probe',
'caucase-monitor = caucase.cli:monitor',
'caucase-rerequest = caucase.cli:rerequest',
'caucase-key-id = caucase.cli:key_id',
'caucased = caucase.http:main',
]
},
test_suite='caucase.test',
)
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment