ABC de Securitatis in Kubernetes: Authenticatio, LICENTIA, Auditing

Serius aut citius, in aliqua operatione systematis, exitus securitatis oritur: procuranda authenticatio, separatio iurium, audiendi et alia opera. iam creatus est ad Kubernetes multae solutionesquae te permittunt obsequia signa consequi etiam in ambitibus exigentibus... Eadem materia vacat fundamentalibus rationibus securitatis, quae intra aedificata machinationes K8s efficiuntur. Imprimis utile erit iis qui incipiunt cognoscere Kubernetes - ut initium ad investigandas quaestiones securitatis relatas.

authenticas

Duo genera usorum in Kubernetes sunt:

• Service Rationes — Rationes a Kubernetibus API tractatae;
• users - "normalis" users ab externis, independens officia administrata.

Praecipua differentia horum generum est quod ad Rationes Service in Kubernetes API objecta specialia sunt (appellantur quae - ServiceAccounts) , quae spatio nominali ligantur et notitiae concessionis in botro in objectis secretorum speciei repositae sunt. Tales utentes (Rationes servitii) principaliter intenduntur ad iura accessum regere ad processuum API Kubernetes in racemum Kubernetes currentium.

Ordinarii Users in Kubernetes API introitus non habent: externa machinamenta tractari debent. Sunt pro hominibus seu processibus extra botrum habitantium.

Quaelibet API petitio vel cum Ratione servitii coniungitur, utentis usoris vel anonymi habetur.

User authenticas notitia includit:

• More - username (causa sensitiva!);
• UID - machinae usoris identitatis chordae readable, quae est "constantior et unica quam usoris usoris";
• Groups - indicem coetuum ad quos usor pertinet;
• Extra - adiectis campis qui auctoritate mechanismo adhiberi possunt.

Kubernetes magnum numerum machinarum authenticarum uti possunt: ​​X509 testimoniales, signa vexillifer, procuratorem authenticum, HTTP Basic Auth. His mechanismis utens, magnum numerum consiliorum concessionis efficere potes: e lima static cum Tesserae ad OpenID OAuth2.

Potest autem eodem tempore pluribus consiliis uti. Defalta botrus utitur;

• servitii ratio signa - for Service Rationes;
• X509 — Pro User.

Quaestio de ServiceAccounts administrandi extra ambitum huius articuli est, sed iis, qui diligentius hanc rem familiariter perscrutari volunt, initium commendamus. documenta publica paginae. Propius inspiciemus exitum quantitatis X509 libellorum elaborandum.

Testimonia pro users (X.509)

Ordo modus operandi cum libellis involvit:

• clavis generationis;

  mkdir -p ~/mynewuser/.certs/
  openssl genrsa -out ~/.certs/mynewuser.key 2048

• testimonium generans petitionem

  openssl req -new -key ~/.certs/mynewuser.key -out ~/.certs/mynewuser.csr -subj "/CN=mynewuser/O=company"

• processus libellum petitionis utens Claves clavium CA Kubernetes, certificatorium usoris obtinendum (ad libellum obtinendum, ratione utere debes quae accessum ad clavem botri CA Kubernetes habet, quae per defaltam in loco sita est. /etc/kubernetes/pki/ca.key):

  openssl x509 -req -in ~/.certs/mynewuser.csr -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial -out ~/.certs/mynewuser.crt -days 500

• configuratione file creando:
  • botrum descriptionem (specificare inscriptionis et locationis tabellae certificamenti CA pro certa botri institutione);

    kubectl config set-cluster kubernetes --certificate-authority=/etc/kubernetes/pki/ca.crt --server=https://192.168.100.200:6443

  • aut quomodo nonoptio commendatur - radicem certificatorium specificare non debes (tunc kubectl rectitudinem botri api-servo non reprehendo);

    kubectl config set-cluster kubernetes  --insecure-skip-tls-verify=true --server=https://192.168.100.200:6443

  • configuratione file ad user addendo:

    kubectl config set-credentials mynewuser --client-certificate=.certs/mynewuser.crt  --client-key=.certs/mynewuser.key

  • contextui addito;

    kubectl config set-context mynewuser-context --cluster=kubernetes --namespace=target-namespace --user=mynewuser

  • default contextu assignment:

    kubectl config use-context mynewuser-context

Manipulationes supra, in tabella .kube/config quasi config homo hic creabitur;

apiVersion: v1
clusters:
- cluster:
    certificate-authority: /etc/kubernetes/pki/ca.crt
    server: https://192.168.100.200:6443
  name: kubernetes
contexts:
- context:
    cluster: kubernetes
    namespace: target-namespace
    user: mynewuser
  name: mynewuser-context
current-context: mynewuser-context
kind: Config
preferences: {}
users:
- name: mynewuser
  user:
    client-certificate: /home/mynewuser/.certs/mynewuser.crt
    client-key: /home/mynewuser/.certs/mynewuser.key

Ut facilius config inter rationes et ministratores transferatur, utile est bona sequentium clavium recensere;

• certificate-authority
• client-certificate
• client-key

Ad hoc faciendum, tabellas in eis de quibus base64 utentes specificatas codere potes et eas in config subcriptio, addito suffixo nomini clavium. -data, i.e. accepto certificate-authority-data etc.

Testimonia cum kubeadm

Cum emissio Kubernetes 1.15 opus cum libellorum facta est multo facilius gratias ad alpha versionis suae sustentationis kubeadm utilitatem. Exempli gratia, hoc est quod configurationem lima generans cum clavibus usoribus fortasse nunc simile est:

kubeadm alpha kubeconfig user --client-name=mynewuser --apiserver-advertise-address 192.168.100.200

NB: required electronica consilium inveniri potest in config api-servo, qui per defaltam in /etc/kubernetes/manifests/kube-apiserver.yaml.

Proin config output ad stdout erit. Servari debet in ~/.kube/config user ratio vel lima certa in an environment variabilis KUBECONFIG.

Altius foderent

Nam qui quaestiones diligentius descriptas intelligere volunt;

• A articulum separatum de operando cum libellis in documentis officialibus Kubernetes;
• bonus articulus ex Bitnamiin quo lis libellorum a practico prospectu attingitur.
• generalis documentum in Kubernetes.

auctoritas

Defalta authentica ratio non habet ius operandi in botro. Ut permissiones concederent, Kubernetes mechanismum auctoritatis inducit.

Prior versionis 1.6, Kubernetes auctorisationis genere usus est nomine ABAC (Additum-substructio secundum imperium). Singula de eo reperiri possunt officialis documenta. Accessus hic nuncius datus est legatum, sed adhuc aliis rationibus authenticis uti potes.

Praesens (et magis flexibile) modus aditum iura dividendi ad botrum vocatur RBAC (Munus-fundatur accessum imperium). Indictum est firmum cum versione Kubernetes 1.8. RBAC exemplar iura exercet in quibus prohibetur omne quod expresse non licet.
Ut RBAC, Kubernetes api-servatores cum modulo incipere debes --authorization-mode=RBAC. Parametri ponuntur in manifesta cum configuratione api-servatori, quae per defaltam in via sita est /etc/kubernetes/manifests/kube-apiserver.yamlIn sectione command. Sed RBAC iam per defaltam enabled, sic maxime verisimile non debes de illo solliciti esse: hoc per valorem cognoscere potes. authorization-mode (Per iam dicta kube-apiserver.yaml). Obiter inter eius significationes aliae licentiae species exstare possunt.node, webhook, always allow) sed considerationem extra materiam relinquemus.

Obiter iam editum est articulus principiorum et lineamentorum cum RBAC satis accurata descriptione, ita me ulterius ad brevitatem fundamentalum et exemplorum enumerabo.

Sequentia API entia in Kubernetes per RBAC moderari solent:

• Role и ClusterRole - munera quae serviunt ad ius aditum describendum;
• Role intra spatium nominandi iura describere permittit;
• ClusterRole - intra botrum, incluso ad objecta botri specialia sicut nodi, delatae facultates non (i.e. ad facultates Kubernetes non pertinentes - e.g. /version, /logs, /api*);
• RoleBinding и ClusterRoleBinding - propter binding Role и ClusterRole ad user, user coetus vel ServiceAccount.

The Munus and RoleBinding entia are limited by name space, i.e. in eodem spatio debet. Nihilominus, RoleBinding referre potest a ClusterRole, quod permittit tibi copiam permissionum genericarum et accessum moderari utentibus illis.

Munera describere iura utendi regulas continentes:

• API coetus - see officialis documenta per apiGroups et output kubectl api-resources;
• facultates (opibus: pod, namespace, deployment et sic porro.);
• Verba (verbs ": set, update etc.).
• resource nomina (resourceNames) - in casu, cum accessum ad certas subsidia praebere debes, nec ad omnes huiusmodi facultates.

Accuratior analysis auctoritatis apud Kubernetes in pagina invenitur officialis documenta. Sed (immo hoc addam) exempla dabo operis illius illustrantia.

Exempla RBAC entitatum

Simple Role, quod tibi permittit ut siliquae indicem et statum habeas ac monitor eos in spatio nominali target-namespace:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: target-namespace
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]

exempli gratia ClusterRolequae permittit tibi ut siliquas indicem et statum habeas et monitor eas per botrum portas;

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  # секции "namespace" нет, так как ClusterRole задействует весь кластер
  name: secret-reader
rules:
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get", "watch", "list"]

exempli gratia RoleBinding, quod permittit utentis mynewuser "Legere" siliquae in spatio nominali my-namespace:

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: target-namespace
subjects:
- kind: User
  name: mynewuser # имя пользователя зависимо от регистра!
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role # здесь должно быть “Role” или “ClusterRole”
  name: pod-reader # имя Role, что находится в том же namespace,
                   # или имя ClusterRole, использование которой
                   # хотим разрешить пользователю
  apiGroup: rbac.authorization.k8s.io

Event audit

Schematically architectura Kubernetarum repraesentari potest hoc modo:

Clavis Kubernetes component responsabilis petitionum processus processus api-servo. Omnes operationes in botro egredientur per eum. Plura de his internis machinationibus in articulo "Quid in Kubernetes accidit, cum kubectl currunt?".

Systema audiendi interesting pluma in Kubernetes est, quae per defaltam debilitata est. Kubernetes API permittit ut omnes vocatos stipes. Ut coniicere possis, actiones omnes ad vigilantiam et mutationem status botri pertinentes per hunc API fiunt. Bona descriptio facultatum eius (ut solet) inveniri in officialis documenta K8s. Deinceps conabor rem simpliciori sermone exhibere.

Sic, ad enable auditingoportet nos tres parametris requisitos ad continens in api-servo transeundum, quae infra fusius describuntur;

• --audit-policy-file=/etc/kubernetes/policies/audit-policy.yaml
• --audit-log-path=/var/log/kube-audit/audit.log
• --audit-log-format=json

Praeter hos tres parametros necessarios, multae accessiones ad audiendum pertinentia sunt: ​​a rotatione loga ad descriptiones webhook. Exemplum gyrationis iniuriarum parametri:

• --audit-log-maxbackup=10
• --audit-log-maxsize=100
• --audit-log-maxage=7

Nos in illis accuratius non habitabimus - omnia singularia invenire potes kube-apiserver documenta.

Ut iam dictum est, omnes parametri sunt in manifesto cum api-servatori configuratione (per default /etc/kubernetes/manifests/kube-apiserver.yaml) In sectione command. Redeamus ad parametros 3 requisitos et eas resolvere;

1. audit-policy-file - iter ad YAML lima consilium computum describens. Posterius ad contenta revertemur, sed nunc notabo tabellam processus api-servatoris esse legendam. Necessarium est igitur illum intra continentem ascendere, cui sequentia notae ad proprias partes config addere potes;

     volumeMounts:
       - mountPath: /etc/kubernetes/policies
         name: policies
         readOnly: true
     volumes:
     - hostPath:
         path: /etc/kubernetes/policies
         type: DirectoryOrCreate
       name: policies

2. audit-log-path — iter ad stipes lima. Semita quoque pervia esse debet ad processum api-servientis, unde eius inscensum eodem modo describimus;

     volumeMounts:
       - mountPath: /var/log/kube-audit
         name: logs
         readOnly: false
     volumes:
     - hostPath:
         path: /var/log/kube-audit
         type: DirectoryOrCreate
       name: logs

3. audit-log-format — format log audit. Congue est jsonsed legatum quoque in forma textui praesto est.legacy).

Audit Policy

Nunc de dicto fasciculo descriptione colligationis consilium. Prima ratio audit consilium est level, logging gradu. Hii sunt:

• None - non log;
• Metadata - metadata stipes postulatio: user, petitio temporis, scopum resource (vasculum, nominale, etc.), genus actionis (verbi) etc.;
• Request - stipes metadata et petitio corporis;
• RequestResponse — metadata loga, corpus et responsionem petitio corporis.

Duo ultima (Request и RequestResponse) petitiones non log quae facultates non accesserunt (accessus ad delata sic dicta non-facultates).

Item omnes petitiones per pluribus gradibus:

• RequestReceived — theatrum, cum petitio a tracto recipitur et nondum per tractorum catenam propagata est;
• ResponseStarted — responsio capitis missi sunt, sed ante corpus responsionis mittitur. Generatae per interrogationes longas (exempli gratia: watch);
• ResponseComplete - Responsum corpus missum est, nihil certius mittetur;
• Panic - generantur eventus cum detegitur abnormis condicio.

Ad skip quoslibet gradus uti potes omitStages.

In consilio lima, plures sectiones cum diversis gradibus colligationis describere possumus. Prima adaptatio regulae inventae in descriptione consiliorum applicabitur.

Monitoria daemonis kubelet cum api-ministro in manifestam configurationem mutat et, si qua deprehenduntur, vas reprimit cum api-servatore. Sed est magna. mutat in consilium lima ut negligatur. Post emendationes fasciculi ad consilium faciendum, necesse est ut manually api-servatori sileo. Quia API servo is coepi ut static pod, team kubectl delete non faciam ut sileo. Quod youll 'have ut faciam illud manually docker stop on kube-masters, ubi consilium computorum mutatum est;

docker stop $(docker ps | grep k8s_kube-apiserver | awk '{print $1}')

Cum enabling auditing, interest ut meminisse onus in kube-apiserver augetur. Praesertim tabes reponendas memoria contextus petentibus augetur. Logging incipit solum postquam responsionis caput mittitur. Onus etiam pendet ex configuratione consilii auditi.

Exempla Politiae

Intueamur structuram consiliorum imaginum utentium exemplis.

Hic fasciculus simplex est policystipes omnia aequo Metadata:

apiVersion: audit.k8s.io/v1
kind: Policy
rules:
- level: Metadata

In consilium usorum notare potes (Users и ServiceAccounts) et coetus user. Exempli gratia, hoc modo nos utentes systematis negligemus, at reliqua omnia in plano stipes Request:

apiVersion: audit.k8s.io/v1
kind: Policy
rules:
  - level: None
    userGroups:
      - "system:serviceaccounts"
      - "system:nodes"
    users:
      - "system:anonymous"
      - "system:apiserver"
      - "system:kube-controller-manager"
      - "system:kube-scheduler"
  - level: Request

Potest etiam describere scuta;

• spatiis nominalibus (namespaces);
• Verba (verbs ": get, update, delete et alii);
• facultates (opibus: Quinque satrapas Philisthinorum: pod, configmaps etc.) et coetus resource (apiGroups).

Dant operam? Facultates et coetus copiarum (API coetus, i.e. apiGroups), tum eorum versiones in botro inauguratae obtineri possunt utens mandata;

kubectl api-resources
kubectl api-versions

Sequenti audit consilium praebetur ut demonstratio optimarum exercitiorum in Alibaba Cloud documentum:

apiVersion: audit.k8s.io/v1beta1
kind: Policy
# Не логировать стадию RequestReceived
omitStages:
  - "RequestReceived"
rules:
  # Не логировать события, считающиеся малозначительными и не опасными:
  - level: None
    users: ["system:kube-proxy"]
    verbs: ["watch"]
    resources:
      - group: "" # это api group с пустым именем, к которому относятся
                  # базовые ресурсы Kubernetes, называемые “core”
        resources: ["endpoints", "services"]
  - level: None
    users: ["system:unsecured"]
    namespaces: ["kube-system"]
    verbs: ["get"]
    resources:
      - group: "" # core
        resources: ["configmaps"]
  - level: None
    users: ["kubelet"]
    verbs: ["get"]
    resources:
      - group: "" # core
        resources: ["nodes"]
  - level: None
    userGroups: ["system:nodes"]
    verbs: ["get"]
    resources:
      - group: "" # core
        resources: ["nodes"]
  - level: None
    users:
      - system:kube-controller-manager
      - system:kube-scheduler
      - system:serviceaccount:kube-system:endpoint-controller
    verbs: ["get", "update"]
    namespaces: ["kube-system"]
    resources:
      - group: "" # core
        resources: ["endpoints"]
  - level: None
    users: ["system:apiserver"]
    verbs: ["get"]
    resources:
      - group: "" # core
        resources: ["namespaces"]
  # Не логировать обращения к read-only URLs:
  - level: None
    nonResourceURLs:
      - /healthz*
      - /version
      - /swagger*
  # Не логировать сообщения, относящиеся к типу ресурсов “события”:
  - level: None
    resources:
      - group: "" # core
        resources: ["events"]
  # Ресурсы типа Secret, ConfigMap и TokenReview могут содержать  секретные данные,
  # поэтому логируем только метаданные связанных с ними запросов
  - level: Metadata
    resources:
      - group: "" # core
        resources: ["secrets", "configmaps"]
      - group: authentication.k8s.io
        resources: ["tokenreviews"]
  # Действия типа get, list и watch могут быть ресурсоёмкими; не логируем их
  - level: Request
    verbs: ["get", "list", "watch"]
    resources:
      - group: "" # core
      - group: "admissionregistration.k8s.io"
      - group: "apps"
      - group: "authentication.k8s.io"
      - group: "authorization.k8s.io"
      - group: "autoscaling"
      - group: "batch"
      - group: "certificates.k8s.io"
      - group: "extensions"
      - group: "networking.k8s.io"
      - group: "policy"
      - group: "rbac.authorization.k8s.io"
      - group: "settings.k8s.io"
      - group: "storage.k8s.io"
  # Уровень логирования по умолчанию для стандартных ресурсов API
  - level: RequestResponse
    resources:
      - group: "" # core
      - group: "admissionregistration.k8s.io"
      - group: "apps"
      - group: "authentication.k8s.io"
      - group: "authorization.k8s.io"
      - group: "autoscaling"
      - group: "batch"
      - group: "certificates.k8s.io"
      - group: "extensions"
      - group: "networking.k8s.io"
      - group: "policy"
      - group: "rbac.authorization.k8s.io"
      - group: "settings.k8s.io"
      - group: "storage.k8s.io"
  # Уровень логирования по умолчанию для всех остальных запросов
  - level: Metadata

Aliud bonum exemplum audit consilium est profile in GCE *.

Ad res audiendas celeriter respondere, fieri potest describere webhook. Hac tegitur officialis documenta, extra ambitum huius articuli relinquam.

results

Articulus speculationem praebet machinarum securitatis fundamentalis in racemis Kubernetes, quae permittit te rationes usoris personales creare, iura separare et actiones suas commemorare. Spero fore utilia iis qui eiusmodi quaestiones in theoria vel in praxi versantur. Commendo etiam te legere indicem aliarum materiarum in argumento securitatis in Kubernetes, qui "PS" ponitur - apud eos fortasse singula necessaria reperias in quaestionibus quae ad te pertinentes.

PS

Lege etiam in nostro diario:

• «33+ instrumenta securitatis Kubernetes";
• «Introductio ad Kubernetes Network Politiae pro Securitatis Professionals";
• «Intellectus RBAC in Kubernetes";
• «9 Best Practices pro Kubernetes Securitatis";
• «11 Mores (Not) Fieri Victimae Kubernetes Hack".

Source: www.habr.com