[PHP] Updaten CMS systeem via Centrale FTP

[Reboot]

Hallo,

Ik ben bezig met een verbetering in ons CMS.
Ik wil dat ik het Admin gedeelte kan updaten via een simpele klik.

Ik werk met het Zend Framework, het gaat vooral om de Controllers in de Admin module die aangepast worden.

Op dit moment werkt het ongeveer zo:


Op mijn server heb ik verschillende versies van het cms.
bv:V2.0

Daarbij horend heb ik een xml bestand:

PHP:

<?xml version="1.0" encoding="utf-8"?>
<files version="2.0">
    <updatefile id="1">
        <file>BlockController.php</file>
        <location>/application/modules/admin/controllers/</location>
    </updatefile>
    <updatefile id="2">
        <file>version.xml</file>
        <location>/library/CMS/Licence/</location>
    </updatefile>
</files>

In dit bestand geef ik aan welke de nieuwe versie is en welke bestanden een update moeten krijgen.
Vervolgens worden door mijn class de versies gecontroleerd de rechten tijdelijk op schrijfbaar gezet en de nieuwe inhoud erin geschreven.

Op de websites zelf is ook een bestand aanwezig waarin staat welke versie het is.

Nu voor het controleren maak ik een ftp verbinding met mijn server en controleer ik de licenties.
Maar dit lijkt me niet zo heel veilig.

heeft iemand een idee hoe ik dit beter zou kunnen doen?


Stukje uit de class

PHP:

<?php
    public function indexAction()
    {
        $docroot=getenv("DOCUMENT_ROOT");
        $licence = new CMS_Licence_Licence();
        if($licence->version()==1){
            $this->view->msg='CMS is up to date.';
        }else{
            $data=$licence->version();
            if($data['current']<>$data['new']){
                $this->view->version=$data;
                $this->view->msg='CMS is niet up to date.';
                // Changelog ophalen
                $doc = new DOMDocument();
                $doc->load('http://licence.**eendomein**.be/versions/'.$data['new'].'.xml');
                $updatefiles= $doc->getElementsByTagName( "updatefile" ); 
                $i=0;
                foreach( $updatefiles as $updatefile)
                {
                    $i++;
                    $files = $updatefile->getElementsByTagName( "file" );
                    $file[$i]['name'] = $files->item(0)->nodeValue; 
                    $locations = $updatefile->getElementsByTagName( "location" );
                    $file[$i]['location'] = $locations->item(0)->nodeValue; 
                    
                }
                $this->view->files=$file;
                echo '<br>';
                $error=false;
                $q = Doctrine_Query::CREATE()
                    ->from('CMS_model_Settings');
                $result = $q->fetchArray();
                // FTP verbinding checken
                $ftp_server = $result[0]['ftp'];
                $ftp_user_name = $result[0]['ftpuser'];
                $ftp_user_pass = $result[0]['ftppwd'];
                foreach($file as $f){
                    // instellingen instellen
                    $local_file = $docroot.$f['location'].$f['name'];
                    $ftp_file = '/public_html/'.$f['location'].$f['name'];
                    $file = $local_file;
                    // connectie maken
                    $conn_id = ftp_connect($ftp_server);
                    // inloggen
                    $login_result = ftp_login($conn_id, $ftp_user_name, $ftp_user_pass);
                    // chmodden
                    if (ftp_chmod($conn_id, 0777, $ftp_file) !== false) {
                     echo $f['name'].' => Schrijfrechten gegeven <br>';
                    } else {
                     $error=true;
                     echo 'Kon geen rechten geven aan '.$f['name'].'<br>';
                    }
                    // verbinding sluiten
                    ftp_close($conn_id);
                    //
                    $server_file = '/public_html/licence/versions/'.$data['new'].$f['location'].$f['name'];
                    // connectie maken
                    $ftp_server='**MIJN FTP**';
                    $conn_id = ftp_connect($ftp_server,21) or die("Couldn't connect to $ftp_server");
                    // inloggen
                    $login_result = ftp_login($conn_id, '**MIJN GEBRUIKER**', '**MIJN WACHTWOOR**');
                    // Bestand downloaden en vervangen
                    if (ftp_get($conn_id, $local_file, $server_file, FTP_BINARY)) {
                        echo 'Update van het bestand <b>'.$f['name'].'</b> gelukt! <br>';
                    } else {
                        $error=true;
                        echo 'Fout bij updaten bestand<br>';
                    }
                    // Verbinding sluiten
                    ftp_close($conn_id);
                    // RESET PERMISSIONS
                    // verbinding maken
                    $conn_id = ftp_connect('**MIJN FTP**');
                    // inloggen
                    $login_result = ftp_login($conn_id, $ftp_user_name, $ftp_user_pass);
                    // chmodden
                    if (ftp_chmod($conn_id, 0644, $ftp_file) !== false) {
                     echo $f['name'].' => Schrijfrechten weggenomen <br>';
                    } else {
                     $error=true;
                     echo 'Kon rechten niet wijzigen van <b>'.$f['name'].'</b> <br>';
                    }
                    // sluiten verbinding
                    ftp_close($conn_id);
                    echo '<hr />';
                }
                if(!$error){
                    echo '<font color="green" size="5">Update voltooid!</font>';
                }else{
                    echo 'Fout bij updaten. Gelieve contact op te nemen met **nvt**';
                }
            }else{
                $this->view->msg='CMS is up to date.';
            }
        }
    }

[Kwastie]

Je zou ook gebruik kunnen maken van git/svn/mercurial om de installaties up-te-daten i.p.v. iets zelf te schrijven

Iedere client geef je _alleen_ toegang tot de code d.m.v. een public key

Je zou ook eventueel kunnen kijken naar Wordpress, die heeft ook een mooie automatische update

[CodeCaster]

Waarom zet je op regel 7 geen return, en waarom draai je de if op regel 9 niet om, en doe je een return op regel 10? Of waarom voeg je ze eigenlijk niet samen? Dus:

PHP:

$data = $licence->version();
if (($data == 1) || ($data['current'] == $data['new'])) {
  $this->view->msg = 'CMS is up to date.';
  return;
}

// en dan hier de rest van je code

Nu snap ik sowieso niet dat je $license->version eerst vergelijkt met een integer (wat een impliciete cast impliceert) en later als array behandelt, maar goed.

En waarom gebruik je geen functies om je code op te delen? Wat als een gebruiker een versie overslaat? Waarom log je steeds opnieuw in op de FTP? Waarom chmod je de files op je FTP-server en niet lokaal?

Tot zover uw gratis code review, inhoudelijk heb ik zoals gewoonlijk niks te melden. Hoewel:

Maar dit lijkt me niet zo heel veilig.

Waarom niet dan? En wat heeft het posten van je code trouwens met het principe wat je bespreekt te maken?

Als je kunt uitleggen wat je probleem is, is je code in dit geval irrelevant. Ik zie niet in waarom het downloaden van nieuwe code vanaf een FTP-server die jij beheert onveilig is. Jij beheert de bestanden die erop staan, jij beheert wie er bij kan. Heeft die klant niet betaald, dan disable je zijn account op de FTP-server en krijgt 'ie geen updates meer.

Of hoe bedoel je "veilig" anders?

[Voor 55% gewijzigd door CodeCaster op 08-07-2011 14:33]

[frickY]

Is Phing geen interessante optie voor je?

Gebruik zelf overigens ook geen phing maar rsync over ssh met public-key authenticatie.

[Voor 50% gewijzigd door frickY op 08-07-2011 14:12]

[Reboot]

Er is geen probleem met mijn code. Ik wou het gewoon even erbij vermelden omtrend mijn idee qua veiligheid.
De FTP gegevens van Mijn server zitten erin, als een klant die zou uitlezen en mijn bestandjes om zeep helpt liggen alle sites plat.

Ik vroeg mij gewoon af of iemand een idee had om dit beter te doen, of een andere optie had.

@fricky ik ga het zeker bekijken!

[Acid_Burn]

Waarom heeft de site die gaat updaten schrijfrechten nodig op jouw ftp server? Zet gewoon dat account op read-only.

[CodeCaster]

Reboot schreef op vrijdag 08 juli 2011 @ 17:35:
Er is geen probleem met mijn code.

Dat zou ik niet zo stellig durven beweren.

De FTP gegevens van Mijn server zitten erin, als een klant die zou uitlezen en mijn bestandjes om zeep helpt liggen alle sites plat.

Dat zeg ik, geef elke klant een eigen login.

[Spectaculous]

Reboot schreef op vrijdag 08 juli 2011 @ 17:35:
Er is geen probleem met mijn code. Ik wou het gewoon even erbij vermelden omtrend mijn idee qua veiligheid.
De FTP gegevens van Mijn server zitten erin, als een klant die zou uitlezen en mijn bestandjes om zeep helpt liggen alle sites plat.

Het account read-only maken zou dit probleem ook oplossen toch? Je zet alleen wel je hele source hiermee in 1 folder. Ik heb een jaar terug zoiets gemaakt. Ik heb gebruik gemaakt van SOAP, een perfect communicatieprotocol voor verkeer tussen servers.

Via SOAP kan je connectie maken vanaf je client server naar je eigen server. Tijdens het maken van de connectie kan je een public key laten meesturen en deze vanuit je eigen database controleren en vervolgens versienummers doorsturen. SOAP kan "reageren" op een bericht waardoor je bij een oude versie zelf lokaal de data uit je file kan ophalen (een extra map op je server die natuurlijk niet leesbaar is voor je browser waar alle recente files instaan) en de inhoud via SOAP naar de client server sturen welke het vervolgens in het juiste bestand zet.

[Reboot]

@codecaster, de code kan beter, dat weet ik mij hij werkt en geeft geen fouten.

@pimoudeveldhuis, dit lijkt me zeer intressant. Dankjewel

[YopY]

Reboot schreef op zaterdag 09 juli 2011 @ 11:04:
@codecaster, de code kan beter, dat weet ik mij hij werkt en geeft geen fouten.

D'r zijn meer criteria aan code dan alleen 'hij maakt geen fouten'. Twee goeie tests:

* Leg eens uit wat de functie allemaal doet?
* Hoeveel tijd heeft een collega (of, indien je die niet hebt, iemand van hier) nodig om de functie te herschrijven (zodanig dat hij precies hetzelfde doet)?

Onderhoudbaarheid, uitbreidbaarheid, aanpasbaarheid, buggevoeligheid, en noem zo nog maar eens een paar heidenen zijn minstens zo belangrijk als 'het werkt'.

/rant

[MueR]

Waarom zou je uberhaupt jouw FTP nodig hebben om een update uit te kunnen voeren? Gewoon de updates in een tarball stoppen en die met curl of whatever binnenhalen. Vervolgens vraag je de FTP login van de klant om spul te overschrijven. Zo werkt wordpress ook en dat werkt best goed.

[ZpAz]

MueR schreef op zaterdag 09 juli 2011 @ 12:10:
Waarom zou je uberhaupt jouw FTP nodig hebben om een update uit te kunnen voeren? Gewoon de updates in een tarball stoppen en die met curl of whatever binnenhalen. Vervolgens vraag je de FTP login van de klant om spul te overschrijven. Zo werkt wordpress ook en dat werkt best goed.

Volgens mij vraagt WordPress de eerste keer toch echt om FTP gegevens.

[MueR]

Jouw FTP gegevens ja, van de account waar jij je wordpress geinstalleerd hebt. Dat kan je gewoon afvangen door een configje te maken met die informatie.

edit:
De voornaamste reden om de bestanden via de FTP van de klant te doen is file ownership. Als PHP een nieuw bestand aan maakt, wordt het doorgaans op de apache user gezet, waar jij vervolgens met je eigen user niets mee mag (behalve lezen). Een bestand updaten kan ook alleen maar als de bestanden onder de apache user staan, of op world-writeable staan. Geen van beiden is enorm aan te raden.

[Voor 56% gewijzigd door MueR op 09-07-2011 13:45]