www/manager6/node/Certificates.js

   1 Ext.define('PVE.node.CertificateView', {
   2     extend: 'Ext.container.Container',
   3     xtype: 'pveCertificatesView',
   4
   5     onlineHelp: 'sysadmin_certificate_management',
   6
   7     mixins: ['Proxmox.Mixin.CBind'],
   8
   9     items: [
  10         {
  11             xtype: 'pveCertView',
  12             border: 0,
  13             cbind: {
  14                 nodename: '{nodename}',
  15             },
  16         },
  17         {
  18             xtype: 'pveACMEView',
  19             border: 0,
  20             cbind: {
  21                 nodename: '{nodename}',
  22             },
  23         },
  24     ],
  25
  26 });
  27
  28 Ext.define('PVE.node.CertificateViewer', {
  29     extend: 'Proxmox.window.Edit',
  30
  31     title: gettext('Certificate'),
  32
  33     fieldDefaults: {
  34         labelWidth: 120,
  35     },
  36     width: 800,
  37     resizable: true,
  38
  39     items: [
  40         {
  41             xtype: 'displayfield',
  42             fieldLabel: gettext('Name'),
  43             name: 'filename',
  44         },
  45         {
  46             xtype: 'displayfield',
  47             fieldLabel: gettext('Fingerprint'),
  48             name: 'fingerprint',
  49         },
  50         {
  51             xtype: 'displayfield',
  52             fieldLabel: gettext('Issuer'),
  53             name: 'issuer',
  54         },
  55         {
  56             xtype: 'displayfield',
  57             fieldLabel: gettext('Subject'),
  58             name: 'subject',
  59         },
  60         {
  61             xtype: 'displayfield',
  62             fieldLabel: gettext('Public Key Type'),
  63             name: 'public-key-type',
  64         },
  65         {
  66             xtype: 'displayfield',
  67             fieldLabel: gettext('Public Key Size'),
  68             name: 'public-key-bits',
  69         },
  70         {
  71             xtype: 'displayfield',
  72             fieldLabel: gettext('Valid Since'),
  73             renderer: Proxmox.Utils.render_timestamp,
  74             name: 'notbefore',
  75         },
  76         {
  77             xtype: 'displayfield',
  78             fieldLabel: gettext('Expires'),
  79             renderer: Proxmox.Utils.render_timestamp,
  80             name: 'notafter',
  81         },
  82         {
  83             xtype: 'displayfield',
  84             fieldLabel: gettext('Subject Alternative Names'),
  85             name: 'san',
  86             renderer: PVE.Utils.render_san,
  87         },
  88         {
  89             xtype: 'textarea',
  90             editable: false,
  91             grow: true,
  92             growMax: 200,
  93             fieldLabel: gettext('Certificate'),
  94             name: 'pem',
  95         },
  96     ],
  97
  98     initComponent: function() {
  99         var me = this;
 100
 101         if (!me.cert) {
 102             throw "no cert given";
 103         }
 104
 105         if (!me.nodename) {
 106             throw "no nodename given";
 107         }
 108
 109         me.url = '/nodes/' + me.nodename + '/certificates/info';
 110         me.callParent();
 111
 112         // hide OK/Reset button, because we just want to show data
 113         me.down('toolbar[dock=bottom]').setVisible(false);
 114
 115         me.load({
 116             success: function(response) {
 117                 if (Ext.isArray(response.result.data)) {
 118                     Ext.Array.each(response.result.data, function(item) {
 119                         if (item.filename === me.cert) {
 120                             me.setValues(item);
 121                             return false;
 122                         }
 123                     });
 124                 }
 125             },
 126         });
 127     },
 128 });
 129
 130 Ext.define('PVE.node.CertUpload', {
 131     extend: 'Proxmox.window.Edit',
 132     xtype: 'pveCertUpload',
 133
 134     title: gettext('Upload Custom Certificate'),
 135     resizable: false,
 136     isCreate: true,
 137     submitText: gettext('Upload'),
 138     method: 'POST',
 139     width: 600,
 140
 141     apiCallDone: function(success, response, options) {
 142         if (!success) {
 143             return;
 144         }
 145
 146         var txt = gettext('pveproxy will be restarted with new certificates, please reload the GUI!');
 147         Ext.getBody().mask(txt, ['pve-static-mask']);
 148         // reload after 10 seconds automatically
 149         Ext.defer(function() {
 150             window.location.reload(true);
 151         }, 10000);
 152     },
 153
 154     items: [
 155         {
 156             fieldLabel: gettext('Private Key (Optional)'),
 157             labelAlign: 'top',
 158             emptyText: gettext('No change'),
 159             name: 'key',
 160             xtype: 'textarea',
 161         },
 162         {
 163             xtype: 'filebutton',
 164             text: gettext('From File'),
 165             listeners: {
 166                 change: function(btn, e, value) {
 167                     var me = this.up('form');
 168                     e = e.event;
 169                     Ext.Array.each(e.target.files, function(file) {
 170                         PVE.Utils.loadSSHKeyFromFile(file, function(res) {
 171                             me.down('field[name=key]').setValue(res);
 172                         });
 173                     });
 174                     btn.reset();
 175                 },
 176             },
 177         },
 178         {
 179             xtype: 'box',
 180             autoEl: 'hr',
 181         },
 182         {
 183             fieldLabel: gettext('Certificate Chain'),
 184             labelAlign: 'top',
 185             allowBlank: false,
 186             name: 'certificates',
 187             xtype: 'textarea',
 188         },
 189         {
 190             xtype: 'filebutton',
 191             text: gettext('From File'),
 192             listeners: {
 193                 change: function(btn, e, value) {
 194                     var me = this.up('form');
 195                     e = e.event;
 196                     Ext.Array.each(e.target.files, function(file) {
 197                         PVE.Utils.loadSSHKeyFromFile(file, function(res) {
 198                             me.down('field[name=certificates]').setValue(res);
 199                         });
 200                     });
 201                     btn.reset();
 202                 },
 203             },
 204         },
 205         {
 206             xtype: 'hidden',
 207             name: 'restart',
 208             value: '1',
 209         },
 210         {
 211             xtype: 'hidden',
 212             name: 'force',
 213             value: '1',
 214         },
 215     ],
 216
 217     initComponent: function() {
 218         var me = this;
 219
 220         if (!me.nodename) {
 221             throw "no nodename given";
 222         }
 223
 224         me.url = '/nodes/' + me.nodename + '/certificates/custom';
 225
 226         me.callParent();
 227     },
 228 });
 229
 230 Ext.define('pve-certificate', {
 231     extend: 'Ext.data.Model',
 232
 233     fields: ['filename', 'fingerprint', 'issuer', 'notafter', 'notbefore', 'subject', 'san', 'public-key-bits', 'public-key-type'],
 234     idProperty: 'filename',
 235 });
 236
 237 Ext.define('PVE.node.Certificates', {
 238     extend: 'Ext.grid.Panel',
 239     xtype: 'pveCertView',
 240
 241     tbar: [
 242         {
 243             xtype: 'button',
 244             text: gettext('Upload Custom Certificate'),
 245             handler: function() {
 246                 var me = this.up('grid');
 247                 var win = Ext.create('PVE.node.CertUpload', {
 248                     nodename: me.nodename,
 249                 });
 250                 win.show();
 251                 win.on('destroy', me.reload, me);
 252             },
 253         },
 254         {
 255             xtype: 'button',
 256             itemId: 'deletebtn',
 257             text: gettext('Delete Custom Certificate'),
 258             handler: function() {
 259                 var me = this.up('grid');
 260                 Proxmox.Utils.API2Request({
 261                     url: '/nodes/' + me.nodename + '/certificates/custom?restart=1',
 262                     method: 'DELETE',
 263                     success: function(response, opt) {
 264                         var txt = gettext('pveproxy will be restarted with new certificates, please reload the GUI!');
 265                         Ext.getBody().mask(txt, ['pve-static-mask']);
 266                         // reload after 10 seconds automatically
 267                         Ext.defer(function() {
 268                             window.location.reload(true);
 269                         }, 10000);
 270                     },
 271                     failure: function(response, opt) {
 272                         Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 273                     },
 274                 });
 275             },
 276         },
 277         '-',
 278         {
 279             xtype: 'proxmoxButton',
 280             itemId: 'viewbtn',
 281             disabled: true,
 282             text: gettext('View Certificate'),
 283             handler: function() {
 284                 var me = this.up('grid');
 285                 me.view_certificate();
 286             },
 287         },
 288     ],
 289
 290     columns: [
 291         {
 292             header: gettext('File'),
 293             width: 150,
 294             dataIndex: 'filename',
 295         },
 296         {
 297             header: gettext('Issuer'),
 298             flex: 1,
 299             dataIndex: 'issuer',
 300         },
 301         {
 302             header: gettext('Subject'),
 303             flex: 1,
 304             dataIndex: 'subject',
 305         },
 306         {
 307             header: gettext('Public Key Alogrithm'),
 308             flex: 1,
 309             dataIndex: 'public-key-type',
 310             hidden: true,
 311         },
 312         {
 313             header: gettext('Public Key Size'),
 314             flex: 1,
 315             dataIndex: 'public-key-bits',
 316             hidden: true,
 317         },
 318         {
 319             header: gettext('Valid Since'),
 320             width: 150,
 321             dataIndex: 'notbefore',
 322             renderer: Proxmox.Utils.render_timestamp,
 323         },
 324         {
 325             header: gettext('Expires'),
 326             width: 150,
 327             dataIndex: 'notafter',
 328             renderer: Proxmox.Utils.render_timestamp,
 329         },
 330         {
 331             header: gettext('Subject Alternative Names'),
 332             flex: 1,
 333             dataIndex: 'san',
 334             renderer: PVE.Utils.render_san,
 335         },
 336         {
 337             header: gettext('Fingerprint'),
 338             dataIndex: 'fingerprint',
 339             hidden: true,
 340         },
 341         {
 342             header: gettext('PEM'),
 343             dataIndex: 'pem',
 344             hidden: true,
 345         },
 346     ],
 347
 348     reload: function() {
 349         var me = this;
 350         me.rstore.load();
 351     },
 352
 353     set_button_status: function() {
 354         var me = this;
 355         var rec = me.rstore.getById('pveproxy-ssl.pem');
 356
 357         me.down('#deletebtn').setDisabled(!rec);
 358     },
 359
 360     view_certificate: function() {
 361         var me = this;
 362         var selection = me.getSelection();
 363         if (!selection || selection.length < 1) {
 364             return;
 365         }
 366         var win = Ext.create('PVE.node.CertificateViewer', {
 367             cert: selection[0].data.filename,
 368             nodename: me.nodename,
 369         });
 370         win.show();
 371     },
 372
 373     listeners: {
 374         itemdblclick: 'view_certificate',
 375     },
 376
 377     initComponent: function() {
 378         var me = this;
 379
 380         if (!me.nodename) {
 381             throw "no nodename given";
 382         }
 383
 384         me.rstore = Ext.create('Proxmox.data.UpdateStore', {
 385             storeid: 'certs-' + me.nodename,
 386             model: 'pve-certificate',
 387             proxy: {
 388                 type: 'proxmox',
 389                     url: '/api2/json/nodes/' + me.nodename + '/certificates/info',
 390             },
 391         });
 392
 393         me.store = {
 394             type: 'diff',
 395             rstore: me.rstore,
 396         };
 397
 398         me.callParent();
 399
 400         me.mon(me.rstore, 'load', me.set_button_status, me);
 401         me.rstore.startUpdate();
 402         me.on('destroy', me.rstore.stopUpdate, me.rstore);
 403     },
 404 });